PROGRAM PLTOTF(PLFILE,TFMFILE,OUTPUT);

{Originally PROGRAM PLTOTF(PLFILE,TFMFILE,OUTPUT),
 but I have moved the argument reading portions elsewhere}

{$I "Include:Utils/StringLib.i"}
{$I "Include:Utils/Parameters.i"}
{$I "Include:Utils/Break.i"}

    CONST   BUFSIZE=60;
            MAXHEADERBYT=100;
            MAXPARAMWORD=30;
            MAXLIGSTEPS=5000;
            MAXKERNS=500;
            HASHSIZE=5003;
            
    TYPE    {BYTE=0..255;}
            ASCIICODE=SHORT;
            
            FOURBYTES=RECORD B0:BYTE;B1:BYTE;B2:BYTE;B3:BYTE;END;
            FIXWORD=INTEGER;
            HEADERINDEX=SHORT;
            INDX=SHORT; {Originally 0..32767}
            
            POINTER=INTEGER;
            
    VAR     PLFILE:TEXT;
            TFMFILE:FILE OF BYTE;
            INFILE,OUTFILE:STRING;
            {Adding space to hold filenames (passed as arguments to pltotf)}
            XORD:ARRAY[0..255]OF ASCIICODE;
            {Originally XORD:ARRAY[CHAR]OF ASCIICODE;}
            
            LINE:INTEGER;
            GOODINDENT:INTEGER;
            INDENT:INTEGER;
            LEVEL:INTEGER;

            LEFTLN,RIGHTLN:BOOLEAN;
            LIMIT:SHORT;
            LOC:SHORT;
            BUFFER:ARRAY[1..BUFSIZE]OF CHAR;
            INPUTHASENDE:BOOLEAN;
            CHARSONLINE:SHORT;
            CURCHAR:ASCIICODE;
            
            START:ARRAY[1..88]OF INTEGER;
            DICTIONARY:ARRAY[0..600]OF ASCIICODE;
            STARTPTR:SHORT;
            DICTPTR:INTEGER;
            CURNAME:ARRAY[1..20]OF ASCIICODE;
            NAMELENGTH:SHORT;
            NAMEPTR:SHORT;
            
            
            DL,DH:BYTE;
            {two new variables added to hold byte sized low and high bytes}
            NHASH:ARRAY[0..100]OF BYTE;
            CURHASH:SHORT;
            EQUIV:ARRAY[0..88]OF BYTE;
            CURCODE:SHORT;
            CURBYTES:FOURBYTES;
            FRACTIONDIGI:ARRAY[1..7]OF INTEGER;
            HEADERBYTES:ARRAY[0..MAXHEADERBYT]OF BYTE;
            HEADERPTR:HEADERINDEX;
            DESIGNSIZE:FIXWORD;
            DESIGNUNITS:FIXWORD;
            SEVENBITSAFE:BOOLEAN;
            LIGKERN:ARRAY[0..MAXLIGSTEPS]OF FOURBYTES;
            NL:INTEGER;MINNL:INTEGER;
            KERN:ARRAY[0..MAXKERNS]OF FIXWORD;
            NK:INTEGER;
             EXTEN:ARRAY[0..255]OF FOURBYTES;
            NE:SHORT; {Originally 0..256}
            PARAM:ARRAY[1..MAXPARAMWORD]OF FIXWORD;
            NP:SHORT;
            CHECKSUMSPEC:BOOLEAN;
            BCHAR:SHORT; {Originally 0..256}
            MEMORY:ARRAY[0..1032]OF FIXWORD;
            MEMPTR:POINTER;
            LINK:ARRAY[0..1032]OF POINTER;
            CHARWD:ARRAY[0..255]OF POINTER;
            CHARHT:ARRAY[0..255]OF POINTER;
            CHARDP:ARRAY[0..255]OF POINTER;
            CHARIC:ARRAY[0..255]OF POINTER;
            CHARTAG:ARRAY[0..255]OF BYTE;
            CHARREMAINDE:ARRAY[0..256]OF INTEGER; {originally of 0..65535}
            
            NEXTD:FIXWORD;
            INDEX:ARRAY[0..1032]OF BYTE;
            EXCESS:SHORT;
            C:SHORT;
            LKSTEPENDED:BOOLEAN;
            KRNPTR:SHORT;
            SEVENUNSAFE:BOOLEAN;
            DELTA:FIXWORD;
            LIGPTR:SHORT;
            {Replaced HASH with PLHASH}
            PLHASH:ARRAY[0..5003]OF INTEGER;
            CLASS:ARRAY[0..5003]OF BYTE;
            LIGZ:ARRAY[0..5003]OF SHORT; {Originally OF 0..257}
            HASHPTR:SHORT;
            HASHLIST:ARRAY[0..5003]OF SHORT;
            H,HH:SHORT; {Originally 0..5003}
            TT:INDX;
            XLIGCYCLE,YLIGCYCLE:SHORT; {Originally 0..256}
            BC:SHORT;EC:SHORT;LH:SHORT;
            LF:SHORT;
            NOTFOUND:BOOLEAN;
            TEMPWIDTH:FIXWORD;
            J:0..MAXHEADERBYT;
            P:POINTER;
            Q:SHORT;
            PARPTR:0..MAXPARAMWORD; 
            LABELTABLE:ARRAY[0..256]OF RECORD 
             RR:INTEGER; {used to be -1..32767}
             CC:SHORT;
            END;
            
            LABELPTR:SHORT;
            SORTPTR:SHORT;
            LKOFFSET:SHORT;
            T:SHORT;
            EXTRALOCNEED:BOOLEAN;
            
PROCEDURE INITIALIZE;

    VAR     K:INTEGER;
            H:SHORT;
            D:HEADERINDEX;
            C:SHORT;
            
BEGIN 

WRITELN('This is PLtoTF, Version 3.4');

    {Inserted following lines to read arguments}
    
    INFILE := AllocString(256);
    OUTFILE := AllocString(256);

    GetParam(1,INFILE);
    GetParam(2,OUTFILE);

    if (strlen(INFILE) <= 0) or (strlen(OUTFILE) <= 0) then begin
	 Writeln('Usage: PLtoTF infile outfile');
	 Exit(20);
    end;

    {End of insertion}

RESET(PLFILE,INFILE,4096);
REWRITE(TFMFILE,OUTFILE,4096);
FOR K:=0 TO 127 DO XORD[K]:=127;
XORD[ORD(' ')]:=32;XORD[ORD('!')]:=33;XORD[ORD('"')]:=34;XORD[ORD('#')]:=35;XORD[ORD('$')]:=36;
XORD[ORD('%')]:=37;XORD[ORD('&')]:=38;XORD[ORD('\'')]:=39;XORD[ORD('(')]:=40;XORD[ORD(')')]:=41;
XORD[ORD('*')]:=42;XORD[ORD('+')]:=43;XORD[ORD(',')]:=44;XORD[ORD('-')]:=45;XORD[ORD('.')]:=46;
XORD[ORD('/')]:=47;XORD[ORD('0')]:=48;XORD[ORD('1')]:=49;XORD[ORD('2')]:=50;XORD[ORD('3')]:=51;
XORD[ORD('4')]:=52;XORD[ORD('5')]:=53;XORD[ORD('6')]:=54;XORD[ORD('7')]:=55;XORD[ORD('8')]:=56;
XORD[ORD('9')]:=57;XORD[ORD(':')]:=58;XORD[ORD(';')]:=59;XORD[ORD('<')]:=60;XORD[ORD('=')]:=61;
XORD[ORD('>')]:=62;XORD[ORD('?')]:=63;XORD[ORD('@')]:=64;XORD[ORD('A')]:=65;XORD[ORD('B')]:=66;
XORD[ORD('C')]:=67;XORD[ORD('D')]:=68;XORD[ORD('E')]:=69;XORD[ORD('F')]:=70;XORD[ORD('G')]:=71;
XORD[ORD('H')]:=72;XORD[ORD('I')]:=73;XORD[ORD('J')]:=74;XORD[ORD('K')]:=75;XORD[ORD('L')]:=76;
XORD[ORD('M')]:=77;XORD[ORD('N')]:=78;XORD[ORD('O')]:=79;XORD[ORD('P')]:=80;XORD[ORD('Q')]:=81;
XORD[ORD('R')]:=82;XORD[ORD('S')]:=83;XORD[ORD('T')]:=84;XORD[ORD('U')]:=85;XORD[ORD('V')]:=86;
XORD[ORD('W')]:=87;XORD[ORD('X')]:=88;XORD[ORD('Y')]:=89;XORD[ORD('Z')]:=90;XORD[ORD('[')]:=91;
XORD[ORD('\'')]:=92;XORD[ORD(']')]:=93;XORD[ORD('^')]:=94;XORD[ORD('_')]:=95;XORD[ORD('`')]:=96;
XORD[ORD('a')]:=97;XORD[ORD('b')]:=98;XORD[ORD('c')]:=99;XORD[ORD('d')]:=100;XORD[ORD('e')]:=101;
XORD[ORD('f')]:=102;XORD[ORD('g')]:=103;XORD[ORD('h')]:=104;XORD[ORD('i')]:=105;
XORD[ORD('j')]:=106;XORD[ORD('k')]:=107;XORD[ORD('l')]:=108;XORD[ORD('m')]:=109;
XORD[ORD('n')]:=110;XORD[ORD('o')]:=111;XORD[ORD('p')]:=112;XORD[ORD('q')]:=113;
XORD[ORD('r')]:=114;XORD[ORD('s')]:=115;XORD[ORD('t')]:=116;XORD[ORD('u')]:=117;
XORD[ORD('v')]:=118;XORD[ORD('w')]:=119;XORD[ORD('x')]:=120;XORD[ORD('y')]:=121;
XORD[ORD('z')]:=122;XORD[ORD('{')]:=123;XORD[ORD('|')]:=124;XORD[ORD('}')]:=125;
XORD[ORD('~')]:=126;

LINE:=0; GOODINDENT:=0; INDENT:=0; LEVEL:=0;

LIMIT:=0;LOC:=0;LEFTLN:=TRUE;RIGHTLN:=TRUE;INPUTHASENDE:=FALSE;

CHARSONLINE:=0; STARTPTR:=1; START[1]:=0; DICTPTR:=0;

FOR H:=0 TO 100 DO NHASH[H]:=0;
FOR D:=0 TO 18*4-1 DO HEADERBYTES[D]:=0;

HEADERBYTES[8]:=11;HEADERBYTES[9]:=85;HEADERBYTES[10]:=78;HEADERBYTES[11]:=83;
HEADERBYTES[12]:=80;HEADERBYTES[13]:=69;HEADERBYTES[14]:=67;
HEADERBYTES[15]:=73;HEADERBYTES[16]:=70;HEADERBYTES[17]:=73;
HEADERBYTES[18]:=69;HEADERBYTES[19]:=68;

FOR D:=48 TO 59 DO HEADERBYTES[D]:=HEADERBYTES[D-40];

DESIGNSIZE:=10*1048576;DESIGNUNITS:=1048576;SEVENBITSAFE:=FALSE;
HEADERPTR:=18*4;NL:=0;MINNL:=0;NK:=0;NE:=0;NP:=0;CHECKSUMSPEC:=FALSE;
BCHAR:=256;

CHARREMAINDE[256]:=32767;
FOR C:=0 TO 255 DO BEGIN 
    CHARWD[C]:=0;CHARHT[C]:=0;CHARDP[C]:=0;
    CHARIC[C]:=0;CHARTAG[C]:=0;CHARREMAINDE[C]:=0;
    END;
    
MEMORY[0]:=2147483647;MEMORY[1]:=0;LINK[1]:=0;MEMORY[2]:=0;LINK[2]:=0;MEMORY[3]:=0;LINK[3]:=0;
MEMORY[4]:=0;LINK[4]:=0;MEMPTR:=4;

HASHPTR:=0; YLIGCYCLE:=256;
FOR K:=0 TO 5003 DO 
 PLHASH[K]:=0;

END;

PROCEDURE SHOWERRORCON;

    VAR K:SHORT;

BEGIN 

WRITELN(' (line ',LINE:1,').');
IF NOT LEFTLN THEN WRITE('...');
FOR K:=1 TO LOC DO WRITE(BUFFER[K]);
WRITELN(' ');
IF NOT LEFTLN THEN WRITE('   ');
FOR K:=1 TO LOC DO WRITE(' ');
FOR K:=LOC+1 TO LIMIT DO WRITE(BUFFER[K]);
IF RIGHTLN THEN WRITELN(' ')ELSE WRITELN('...');
CHARSONLINE:=0;

END;

PROCEDURE FILLBUFFER;

BEGIN 

LEFTLN:=RIGHTLN;LIMIT:=0;LOC:=0;
IF LEFTLN THEN BEGIN 
    { Originally included ... IF LINE>0 THEN READLN(PLFILE);
      This assumes that the EOL has not been read yet, but it
      has!  This is because PCQ does not have EOLN, and so
      I had to read the EOL before detecting it!}
    LINE:=LINE+1;
END;
      
IF EOF(PLFILE)THEN BEGIN
    WRITELN(' ');               {added by me}
    WRITELN('EOF reached');
    LIMIT:=1;
    BUFFER[1]:=')';
    RIGHTLN:=FALSE;
    INPUTHASENDE:=TRUE;
END ELSE BEGIN 
    {Originally the line below was...
        WHILE(LIMIT<BUFSIZE-1)AND(NOT EOLN(PLFILE))DO BEGIN 
     but PCQ Pascal does not appear to have EOLN?!
     
     In addition, version 2.4 of CJK creates a PLFILE which
     does not have a terminating newline.  For this reason,
     an EOF may occur `mid-line'.  Some of the code below
     tries to compensate for this.}
     
    WHILE (LIMIT<BUFSIZE-1) AND (NOT EOF(PLFILE)) 
    AND (NOT((LIMIT>0) AND (BUFFER[LIMIT]='\n'))) DO BEGIN 
        LIMIT:=LIMIT+1;
        READ(PLFILE,BUFFER[LIMIT]);
    END;
    {A few lines to compensate for the possiblity of an EOF
     in the `middle' of a line.}
    IF EOF(PLFILE)THEN BEGIN
        LIMIT:=LIMIT+1;
        BUFFER[LIMIT]:='\n';
    END;
    {Originally something like... BUFFER[LIMIT+1]:=' ';
                                  RIGHTLN:=EOLN(PLFILE);
     This has been replaced with the following 3 lines,
     which includes a `kludge' allowing for the failure
     to `detect' EOL until it was `too late'.}
    RIGHTLN:=(BUFFER[LIMIT]='\n');
    BUFFER[LIMIT]:=' ';
    LIMIT:=LIMIT-1;
    IF LEFTLN THEN BEGIN 
        WHILE(LOC<LIMIT)AND(BUFFER[LOC+1]=' ') DO 
            LOC:=LOC+1;
        IF LOC<LIMIT THEN BEGIN 
            IF LEVEL=0 THEN 
                IF LOC=0 THEN 
                    GOODINDENT:=GOODINDENT+1 
                ELSE BEGIN 
                    IF GOODINDENT>=10 THEN BEGIN 
                        IF CHARSONLINE>0 THEN WRITELN(' ');
                        WRITE('Warning: Indented line occurred at level zero');
                        SHOWERRORCON;
                    END;
                    GOODINDENT:=0;INDENT:=0;
                END 
            ELSE IF INDENT=0 THEN 
                IF LOC MOD LEVEL=0 THEN BEGIN 
                    INDENT:=LOC DIV LEVEL;
                    GOODINDENT:=1;
                END ELSE 
                    GOODINDENT:=0 
            ELSE IF INDENT*LEVEL=LOC THEN
                GOODINDENT:=GOODINDENT+1 
            ELSE BEGIN 
                IF GOODINDENT>=10 THEN BEGIN 
                    IF CHARSONLINE>0 THEN 
                        WRITELN(' ');
                    WRITE('Warning: Inconsistent indentation; ','you are at parenthesis level ',LEVEL:1);
                    SHOWERRORCON;
                END;
                GOODINDENT:=0; INDENT:=0;
            END;
        END;
    END;
END;
END;




PROCEDURE GETKEYWORDCH;
BEGIN 

WHILE(LOC=LIMIT)AND(NOT RIGHTLN)DO 
    FILLBUFFER;
IF LOC=LIMIT THEN 
    CURCHAR:=32 
ELSE BEGIN 
    CURCHAR:=XORD[ORD(BUFFER[LOC+1])];
    IF CURCHAR>=97 THEN CURCHAR:=CURCHAR-32;
    IF((CURCHAR>=48)AND(CURCHAR<=57))THEN 
        LOC:=LOC+1 
    ELSE IF((CURCHAR>=65) AND(CURCHAR<=90))THEN 
        LOC:=LOC+1 
    ELSE IF CURCHAR=47 THEN 
        LOC:=LOC+1 
    ELSE IF CURCHAR=62 THEN 
        LOC:=LOC+1 
    ELSE 
        CURCHAR:=32;
END;
END;

PROCEDURE GETNEXT;

BEGIN 

WHILE LOC=LIMIT DO BEGIN
    FILLBUFFER;
    END;
LOC:=LOC+1;
CURCHAR:=XORD[ORD(BUFFER[LOC])];
IF CURCHAR>=97 THEN 
    IF CURCHAR<=122 THEN 
        CURCHAR:=CURCHAR-32 
    ELSE BEGIN
        IF CURCHAR=127 THEN BEGIN 
            BEGIN 
                IF CHARSONLINE>0 THEN 
                    WRITELN(' ');
                WRITE('Illegal character in the file ');
                WRITE(BUFFER[LOC],' ',ORD(BUFFER[LOC]),' ',CURCHAR);
                SHOWERRORCON;
            END;
            CURCHAR:=63;
        END;
    END 
ELSE IF(CURCHAR<=41)AND(CURCHAR>=40)THEN 
    LOC:=LOC-1;
END;

PROCEDURE SKIPTOENDOFI;
    VAR     L:INTEGER;
    
BEGIN 

L:=LEVEL;
WHILE LEVEL>=L DO BEGIN 
    WHILE LOC=LIMIT DO 
        FILLBUFFER;
    LOC:=LOC+1;
    IF BUFFER[LOC]=')'THEN 
        LEVEL:=LEVEL-1 
    ELSE IF BUFFER[LOC]='('THEN 
        LEVEL:=LEVEL+1;
END;
IF INPUTHASENDE THEN BEGIN 
    IF CHARSONLINE>0 THEN 
        WRITELN(' ');
    WRITE('File ended unexpectedly: No closing ")"');
    SHOWERRORCON;
END;
CURCHAR:=32;
END;

PROCEDURE FINISHTHEPRO;

BEGIN 

WHILE CURCHAR=32 DO 
 GETNEXT;
 IF CURCHAR<>41 THEN BEGIN 
  IF CHARSONLINE>0 THEN 
   WRITELN(' ');
  WRITE('Junk after property value will be ignored');
  SHOWERRORCON;
 END;
 SKIPTOENDOFI;
 

END;

PROCEDURE LOOKUP;
    VAR     K:SHORT;
            J:SHORT;
            NOTFOUND:BOOLEAN;

BEGIN

CURHASH:=CURNAME[1];
FOR K:=2 TO NAMELENGTH DO BEGIN
    CURHASH:=(CURHASH+CURHASH+CURNAME[K])MOD 101;
END;
NOTFOUND:=TRUE;
WHILE NOTFOUND DO BEGIN 
    IF CURHASH=0 THEN 
        CURHASH:=100 
    ELSE 
        CURHASH:=CURHASH-1;
    IF NHASH[CURHASH]=0 THEN BEGIN
        NOTFOUND:=FALSE;  
    END ELSE BEGIN 
        J:=START[NHASH[CURHASH]];
        IF START[NHASH[CURHASH]+1]=J+NAMELENGTH THEN BEGIN 
            NOTFOUND:=FALSE;
            FOR K:=1 TO NAMELENGTH DO BEGIN
                IF DICTIONARY[J+K-1]<>CURNAME[K] THEN
                    NOTFOUND:=TRUE;
            END;
        END;
    END;
END;
NAMEPTR:=NHASH[CURHASH];
END;

PROCEDURE ENTERNAME(V:SHORT);
    VAR     K:SHORT;

BEGIN 

FOR K:=1 TO NAMELENGTH DO 
    CURNAME[K]:=CURNAME[K+20-NAMELENGTH];
LOOKUP;
NHASH[CURHASH]:=STARTPTR;
EQUIV[STARTPTR]:=V;

FOR K:=1 TO NAMELENGTH DO BEGIN 
    DICTIONARY[DICTPTR]:=CURNAME[K];
    DICTPTR:=DICTPTR+1;
END;
STARTPTR:=STARTPTR+1;
START[STARTPTR]:=DICTPTR;
END;

PROCEDURE GETNAME;

    VAR I:INTEGER; {added by D. Fong}
    
BEGIN 
LOC:=LOC+1;
LEVEL:=LEVEL+1;
CURCHAR:=32;
WHILE CURCHAR=32 DO 
    GETNEXT;
IF(CURCHAR>41)OR(CURCHAR<40)THEN 
    LOC:=LOC-1;
NAMELENGTH:=0;
GETKEYWORDCH;
WHILE CURCHAR<>32 DO BEGIN 
    IF NAMELENGTH=20 THEN 
        CURNAME[1]:=88 
    ELSE
        NAMELENGTH:=NAMELENGTH+1;
    CURNAME[NAMELENGTH]:=CURCHAR;
    GETKEYWORDCH;
END;
LOOKUP;
IF NAMEPTR=0 THEN BEGIN 
    IF CHARSONLINE>0 THEN 
        WRITELN(' ');
    {I'm not too sure if the next three lines are in the original}
    FOR I:=1 TO NAMELENGTH DO   
        WRITE(CHR(CURNAME[I]));
    WRITE(' ');
    WRITELN(' - Sorry, I don\'t know that property name.');
    SHOWERRORCON;
END ELSE BEGIN
END;
CURCODE:=EQUIV[NAMEPTR];
END;

FUNCTION GETBYTE:SHORT;
    
VAR     ACC:INTEGER;
        T:ASCIICODE;

BEGIN 

    REPEAT GETNEXT;
    UNTIL CURCHAR<>32;

    T:=CURCHAR;
    ACC:=0;
    REPEAT 
        GETNEXT;
    UNTIL CURCHAR<>32;

    IF T=67 THEN
        IF(CURCHAR>=33)AND(CURCHAR<=126)AND((CURCHAR<40)OR(CURCHAR>41))THEN 
            ACC:=XORD[ORD(BUFFER[LOC])]
        ELSE BEGIN 
            BEGIN 
                IF CHARSONLINE>0 THEN 
                    WRITELN(' ');
                WRITE('"C" value must be standard ASCII and not a paren');
                SHOWERRORCON;
            END;
            REPEAT 
                GETNEXT 
            UNTIL(CURCHAR=40)OR(CURCHAR=41);
        END
    ELSE IF T=68 THEN BEGIN 
        WHILE (CURCHAR>=48)AND(CURCHAR<=57) DO BEGIN 
            ACC:=ACC*10+CURCHAR-48;
            IF ACC>255 THEN BEGIN 
                BEGIN 
                    BEGIN 
                        IF CHARSONLINE>0 THEN 
                            WRITELN(' ');
                        WRITE('This value shouldn\'t exceed 255');
                        SHOWERRORCON;
                    END;
                    REPEAT 
                        GETNEXT 
                    UNTIL(CURCHAR=40)OR(CURCHAR=41);
                END;
                ACC:=0;
                CURCHAR:=32;
            END 
            ELSE 
                GETNEXT;
            END;
        BEGIN 
            IF(CURCHAR>41)OR(CURCHAR<40)THEN 
                LOC:=LOC-1;
        END;
    END 
    ELSE IF T=79 THEN BEGIN 
        WHILE(CURCHAR>=48)AND(CURCHAR<=55)DO BEGIN 
            ACC:=ACC*8+CURCHAR-48;
            IF ACC>255 THEN BEGIN 
                BEGIN 
                    BEGIN 
                        IF CHARSONLINE>0 THEN WRITELN(' ');
                        WRITE('This value shouldn\'t exceed \'377');
                        SHOWERRORCON;
                    END;
                    REPEAT 
                        GETNEXT 
                    UNTIL(CURCHAR=40)OR(CURCHAR=41);
                END;
                ACC:=0;
                CURCHAR:=32;
                END 
            ELSE 
                GETNEXT;
            END;
            BEGIN 
                IF(CURCHAR>41)OR(CURCHAR<40)THEN LOC:=LOC-1;
            END;
        END
    ELSE IF T=72 THEN BEGIN 
        WHILE((CURCHAR>=48)AND(CURCHAR<=57))OR((CURCHAR>=65)AND(CURCHAR<=70))DO BEGIN
            IF CURCHAR>=65 THEN CURCHAR:=CURCHAR-7;
            ACC:=ACC*16+CURCHAR-48;
            IF ACC>255 THEN BEGIN 
                BEGIN 
                    BEGIN 
                        IF CHARSONLINE>0 THEN WRITELN(' ');
                        WRITE('This value shouldn\'t exceed "FF');
                        SHOWERRORCON;
                    END;
                    REPEAT 
                        GETNEXT 
                    UNTIL(CURCHAR=40)OR(CURCHAR=41);
                END;
                ACC:=0;
                CURCHAR:=32;
            END
            ELSE 
                GETNEXT;
            END;
            BEGIN 
                IF(CURCHAR>41)OR(CURCHAR<40)THEN LOC:=LOC-1;
            END;
        END
    ELSE IF T=70 THEN BEGIN
        IF CURCHAR=66 THEN
            ACC:=2
        ELSE IF CURCHAR=76 THEN 
            ACC:=4
        ELSE IF CURCHAR<>77 THEN
            ACC:=18;
        GETNEXT;
        IF CURCHAR=73 THEN
            ACC:=ACC+1
        ELSE IF CURCHAR<>82 THEN
            ACC:=18;
        GETNEXT;
        IF CURCHAR=67 THEN
            ACC:=ACC+6
        ELSE IF CURCHAR=69 THEN
            ACC:=ACC+12
        ELSE IF CURCHAR<>82 THEN
            ACC:=18;
        IF ACC>=18 THEN BEGIN
            BEGIN
                BEGIN
                    IF CHARSONLINE>0 THEN WRITELN(' ');
                    WRITE('Illegal face code, I changed it to MRR');
                    SHOWERRORCON;
                END;
                REPEAT
                    GETNEXT
                UNTIL(CURCHAR=40)OR(CURCHAR=41);
            END;
            ACC:=0;
        END;
    END
    ELSE BEGIN 
        BEGIN
            IF CHARSONLINE>0 THEN WRITELN(' ');
            WRITE('You need "C" or "D" or "O" or "H" or "F" here');
            SHOWERRORCON;
        END;
        REPEAT
            GETNEXT
        UNTIL(CURCHAR=40)OR(CURCHAR=41);
    END;
    CURCHAR:=32;
    GETBYTE:=ACC;
END;

PROCEDURE GETFOURBYTES;

VAR     C:INTEGER;
        R:INTEGER;
        Q:INTEGER;
BEGIN 

 REPEAT
  GETNEXT;
 UNTIL CURCHAR<>32;
 R:=0;
 CURBYTES.B0:=0;
 CURBYTES.B1:=0;
 CURBYTES.B2:=0;
 CURBYTES.B3:=0;
 IF CURCHAR=72 THEN
  R:=16
 ELSE IF CURCHAR=79 THEN
  R:=8
 ELSE BEGIN
  BEGIN
   IF CHARSONLINE>0 THEN WRITELN(' ');
   WRITE('An octal ("O") or hex ("H") value is needed here');
   SHOWERRORCON;
  END;
  REPEAT
   GETNEXT
  UNTIL(CURCHAR=40)OR(CURCHAR=41);
 END;
 IF R>0 THEN BEGIN
  Q:=256 DIV R;
  REPEAT
   GETNEXT;
  UNTIL CURCHAR<>32;
  WHILE((CURCHAR>=48)AND(CURCHAR<=57))OR((CURCHAR>=65)AND(CURCHAR<=70))DO BEGIN
   IF CURCHAR>=65 THEN CURCHAR:=CURCHAR-7;
   C:=(R*CURBYTES.B0)+(CURBYTES.B1 DIV Q);
   IF C>255 THEN BEGIN
    CURBYTES.B0:=0;
    CURBYTES.B1:=0;
    CURBYTES.B2:=0;
    CURBYTES.B3:=0;
    IF R=8 THEN BEGIN
     BEGIN
      IF CHARSONLINE>0 THEN WRITELN(' ');
      WRITE('Sorry, the maximum octal value is O 37777777777');
      SHOWERRORCON;
     END;
     REPEAT
      GETNEXT
     UNTIL(CURCHAR=40)OR(CURCHAR=41);
    END ELSE BEGIN
     BEGIN
      IF CHARSONLINE>0 THEN WRITELN(' ');
      WRITE('Sorry, the maximum hex value is H FFFFFFFF');
      SHOWERRORCON;
     END;
     REPEAT
      GETNEXT
     UNTIL(CURCHAR=40)OR(CURCHAR=41);
    END;
   END ELSE IF CURCHAR>=48+R THEN BEGIN
    BEGIN
     IF CHARSONLINE>0 THEN WRITELN (' ');
     WRITE('Illegal digit');
     SHOWERRORCON;
    END;
    REPEAT 
     GETNEXT
    UNTIL(CURCHAR=40)OR(CURCHAR=41);
   END ELSE BEGIN
    CURBYTES.B0:=C;
    CURBYTES.B1:=(R*(CURBYTES.B1 MOD Q))+(CURBYTES.B2 DIV Q);
    CURBYTES.B2:=(R*(CURBYTES.B2 MOD Q))+(CURBYTES.B3 DIV Q);
    CURBYTES.B3:=(R*(CURBYTES.B3 MOD Q))+CURCHAR-48;
    GETNEXT;
   END;
  END;
 END;
END;

FUNCTION GETFIX:FIXWORD;

VAR     NEGATIVE:BOOLEAN;
        ACC:INTEGER;
        INTPART:INTEGER;
        J:SHORT;

BEGIN
 REPEAT
  GETNEXT;
 UNTIL CURCHAR<>32;
 NEGATIVE:=FALSE;
 ACC:=0;
 IF(CURCHAR<>82)AND(CURCHAR<>68)THEN BEGIN 
  BEGIN 
   IF CHARSONLINE>0 THEN WRITELN(' ');
   WRITE('An "R" or "D" value is needed here');
   SHOWERRORCON;
  END;
  REPEAT
   GETNEXT
  UNTIL(CURCHAR=40)OR(CURCHAR=41);
 END ELSE BEGIN
  REPEAT
   GETNEXT;
   IF CURCHAR=45 THEN BEGIN
    CURCHAR:=32;
    NEGATIVE:=TRUE;
   END ELSE IF CURCHAR=43 THEN
    CURCHAR:=32;
  UNTIL CURCHAR<>32;
  WHILE(CURCHAR>=48)AND(CURCHAR<=57)DO BEGIN 
   ACC:=ACC*10+CURCHAR-48;
   IF ACC>=2048 THEN BEGIN
    BEGIN
     BEGIN
      IF CHARSONLINE>0 THEN WRITELN(' ');
      WRITE('Real constants must be less than 2048');
      SHOWERRORCON;
     END;
     REPEAT
      GETNEXT
     UNTIL(CURCHAR=40)OR(CURCHAR=41);
    END;
    ACC:=0;
    CURCHAR:=32;
   END ELSE
    GETNEXT;
  END;
  INTPART:=ACC;
  ACC:=0;
  IF CURCHAR=46 THEN BEGIN
   J:=0;
   GETNEXT;
   WHILE(CURCHAR>=48)AND(CURCHAR<=57)DO BEGIN
    IF J<7 THEN BEGIN
     J:=J+1;
     FRACTIONDIGI[J]:=2097152*(CURCHAR-48);
    END;
    GETNEXT;
   END;
   ACC:=0;
   WHILE J>0 DO BEGIN
    ACC:=FRACTIONDIGI[J]+(ACC DIV 10);
    J:=J- 1;
   END;
   ACC:=(ACC+10)DIV 20;
  END;
  IF(ACC>=1048576)AND(INTPART=2047)THEN BEGIN
   BEGIN
    IF CHARSONLINE>0 THEN WRITELN(' ');
    WRITE('Real constants must be less than 2048');
    SHOWERRORCON;
   END;
   REPEAT
    GETNEXT
   UNTIL(CURCHAR=40)OR(CURCHAR=41);
  END ELSE
   ACC:=INTPART*1048576+ACC;
 END;
  
 IF NEGATIVE THEN
  GETFIX:=-ACC
 ELSE
  GETFIX:=ACC;

END;

FUNCTION SORTIN(H:POINTER;D:FIXWORD):POINTER;

VAR     P:POINTER;

BEGIN 

 IF(D=0)AND(H<>1)THEN
  SORTIN:=0
 ELSE BEGIN
  P:=H;
  WHILE D>=MEMORY[LINK[P]]DO
   P:=LINK[P];
  IF(D=MEMORY[P])AND(P<>H)THEN
   SORTIN:=P
  ELSE IF MEMPTR=1032 THEN BEGIN
   BEGIN
    IF CHARSONLINE>0 THEN WRITELN(' ');
    WRITE('Memory overflow: more than 1028 widths, etc');
    SHOWERRORCON;
   END;
   WRITELN('Congratulations! It\'s hard to make this error.');
   SORTIN:=P;
  END ELSE BEGIN
   MEMPTR:=MEMPTR+1;
   MEMORY[MEMPTR]:=D;
   LINK[MEMPTR]:=LINK[P];
   LINK[P]:=MEMPTR;
   MEMORY[H]:=MEMORY[H]+1;
   SORTIN:=MEMPTR;
  END;
 END;
END;

FUNCTION MINCOVER(H:POINTER;D:FIXWORD):INTEGER;

VAR     P:POINTER;
        L:FIXWORD;
        M:INTEGER;

BEGIN 
 
 M:=0;
 P:=LINK[H];
 NEXTD:=MEMORY[0];
 WHILE P<>0 DO BEGIN
  M:=M+1;
  L:=MEMORY[P];
  WHILE MEMORY[LINK[P]]<=L+D DO
   P:=LINK[P];
  P:=LINK[P];
  IF MEMORY[P]-L<NEXTD THEN 
   NEXTD:=MEMORY[P]-L;
 END;
 MINCOVER:=M;
 
END;

FUNCTION SHORTEN(H:POINTER;M:INTEGER):FIXWORD;

VAR     D:FIXWORD;
        K:INTEGER;

BEGIN 

 IF MEMORY[H]>M THEN BEGIN 
  EXCESS:=MEMORY[H]-M;
  K:=MINCOVER(H,0);
  D:=NEXTD;
  REPEAT
   D:=D+D;
   K:=MINCOVER(H,D);
  UNTIL K<=M;
  D:=D DIV 2;
  K:=MINCOVER(H,D);
  WHILE K>M DO BEGIN
   D:=NEXTD;
   K:=MINCOVER(H,D);
  END;
  SHORTEN:=D;
 END ELSE 
  SHORTEN:=0;

END;

PROCEDURE SETINDICES(H:POINTER;D:FIXWORD);

VAR     P:POINTER;
        Q:POINTER;
        M:SHORT;
        L:FIXWORD;

BEGIN 

 Q:=H;
 P:=LINK[Q];
 M:=0;
 WHILE P<>0 DO BEGIN 
  M:=M+1;
  L:=MEMORY[P];
  INDEX[P]:=M;
  WHILE MEMORY[LINK[P]]<=L+D DO BEGIN
   P:=LINK[P];
   INDEX[P]:=M;
   EXCESS:=EXCESS-1;
   IF EXCESS=0 THEN D:=0;
  END;
  LINK[Q]:=P;
  MEMORY[P]:=L+(MEMORY[P]-L)DIV 2;
  Q:=P;
  P:=LINK[P];
 END;
 MEMORY[H]:=M;
 
END;

PROCEDURE JUNKERROR;

BEGIN

 BEGIN
  IF CHARSONLINE>0 THEN WRITELN(' ');
  WRITE('There\'s junk here that is not in parentheses');
  SHOWERRORCON;
 END;
 REPEAT
  GETNEXT
 UNTIL(CURCHAR=40)OR(CURCHAR=41);

END;

PROCEDURE READFOURBYTE(L:HEADERINDEX);

BEGIN
 GETFOURBYTES;
 HEADERBYTES[L]:=CURBYTES.B0;
 HEADERBYTES[L+1]:=CURBYTES.B1;
 HEADERBYTES[L+2]:=CURBYTES.B2;
 HEADERBYTES[L+3]:=CURBYTES.B3;

END;

PROCEDURE READBCPL(L:HEADERINDEX;N:SHORT);

VAR     K:HEADERINDEX;

BEGIN 

 K:=L;
 WHILE CURCHAR=32 DO
  GETNEXT;
 WHILE(CURCHAR<>40)AND(CURCHAR<>41)DO BEGIN
  IF K<L+N THEN K:=K+1;
  IF K<L+N THEN HEADERBYTES[K]:=CURCHAR;
  GETNEXT;
 END;
 IF K=L+N THEN BEGIN
  BEGIN
   IF CHARSONLINE>0 THEN WRITELN(' ');
   WRITE('String is too long; its first ',N-1:1,' characters will be kept');
   SHOWERRORCON;
  END;
  K:=K-1;
 END;
 HEADERBYTES[L]:=K-L;
 WHILE K<L+N-1 DO BEGIN
  K:=K+1;
  HEADERBYTES[K]:=0;
 END;

END;

PROCEDURE CHECKTAG(C:SHORT);
 
BEGIN

 CASE CHARTAG[C]OF 
  0:;
  1:BEGIN
   IF CHARSONLINE>0 THEN WRITELN(' ');
   WRITE('This character already appeared in a LIGTABLE LABEL');
   SHOWERRORCON;
   END;
  2:BEGIN
   IF CHARSONLINE>0 THEN WRITELN(' ');
   WRITE('This character already has a NEXTLARGER spec');
   SHOWERRORCON;
   END;
  3:BEGIN
   IF CHARSONLINE>0 THEN WRITELN(' ');
   WRITE('This character already has a VARCHAR spec');
   SHOWERRORCON;
   END;
 END;
END;

PROCEDURE PRINTOCTAL(C:SHORT);

BEGIN
 
 WRITE('\'',(C DIV 64):1,((C DIV 8)MOD 8):1,(C MOD 8):1);
 
END;

FUNCTION HASHINPUT(P,C:INDX):BOOLEAN;

LABEL   JUMP;  {Originally LABEL 30, but PCQ Pascal only accepts alphabets for Label}
VAR     CC:SHORT;
        ZZ:SHORT;
        Y:SHORT;
        KEY:INTEGER;
        T:INTEGER;

BEGIN

 IF HASHPTR=5003 THEN BEGIN
  HASHINPUT:=FALSE;
  GOTO JUMP;
 END;
 Y:=LIGKERN[P].B1;
 T:=LIGKERN[P].B2;
 CC:=0;
 ZZ:=LIGKERN[P].B3;
 IF T>=128 THEN ZZ:=Y ELSE BEGIN
  CASE T OF 
  0,6:;
  5,11:
   ZZ:=Y;
  1,7:
   CC:=1;
  2:
   CC:=2;
  3:
   CC:=3;
  END;
 END;
 KEY:=256*C+Y+1;
 H:=(1009*KEY)MOD 5003;
 WHILE PLHASH[H]>0 DO BEGIN
  IF PLHASH[H]<=KEY THEN BEGIN
   IF PLHASH[H]=KEY THEN BEGIN
    HASHINPUT:=FALSE;
    GOTO JUMP;
   END;
   T:=PLHASH[H];
   PLHASH[H]:=KEY;
   KEY:=T;
   T:=CLASS[H];
   CLASS[H]:=CC;
   CC:=T;
   T:=LIGZ[H];
   LIGZ[H]:=ZZ;
   ZZ:=T;
  END;
  IF H>0 THEN
   H:=H-1
  ELSE
   H:=5003;
 END;
 PLHASH[H]:=KEY;
 CLASS[H]:=CC;
 LIGZ[H]:=ZZ;
 HASHPTR:=HASHPTR+1;
 HASHLIST[HASHPTR]:=H;
 HASHINPUT:=TRUE;
 
 JUMP:

END;
  
FUNCTION F(H,X,Y:INDX):INDX;

FORWARD;

FUNCTION EVAL(X,Y:INDX):INDX;

VAR     KEY:INTEGER;

BEGIN 

 KEY:=256*X+Y+1;
 H:=(1009*KEY)MOD 5003;
 WHILE PLHASH[H]>KEY DO
  IF H>0 THEN
   H:=H-1
  ELSE 
   H:=5003;
 IF PLHASH[H]<KEY THEN
  EVAL:=Y
 ELSE 
  EVAL:=F(H,X,Y);
END;

FUNCTION F(H,X,Y:INDX):INDX;

BEGIN
 CASE CLASS[H]OF 
 0:;
 1: BEGIN 
  CLASS[H]:=4;
  LIGZ[H]:=EVAL(LIGZ[H],Y);
  CLASS[H]:=0;
 END;
 2:BEGIN
  CLASS[H]:=4;
  LIGZ[H]:=EVAL(X,LIGZ[H]);
  CLASS[H]:=0;
 END;
 3:BEGIN
  CLASS[H]:=4;
  LIGZ[H]:=EVAL(EVAL(X,LIGZ[H]),Y);
  CLASS[H]:=0;
 END;
 4:BEGIN 
  XLIGCYCLE:=X;
  YLIGCYCLE:=Y;
  LIGZ[H]:=257;
  CLASS[H]:=0;
 END;
 END;
 F:=LIGZ[H];
END;

PROCEDURE OUTSCALED(X:FIXWORD);

VAR     N:BYTE;
        M:INTEGER; {Originally 0..65535, but PCQ does not accept this for MOD}
        OL,OH:BYTE;
        
BEGIN

 IF ABS(X/DESIGNUNITS)>=16.0 THEN BEGIN 
  WRITELN('The relative dimension ',X/1048576:1:3,' is too large.');
  WRITE('  (Must be less than 16*designsize');
  IF DESIGNUNITS<>1048576 THEN
   WRITE(' =',DESIGNUNITS/65536:1:3,' designunits');
  WRITELN(')');
  X:=0;
 END;
 IF DESIGNUNITS<>1048576 THEN
  X:=ROUND((X/DESIGNUNITS)*1048576.0);
 IF X<0 THEN BEGIN
  WRITE(TFMFILE,255);
  X:=X+16777216;
  IF X<=0 THEN
   X:=1;
 END ELSE BEGIN 
  WRITE(TFMFILE,0);
  IF X>=16777216 THEN 
   X:=16777215;
 END;
 N:=X DIV 65536;
 M:=X MOD 65536;
 WRITE(TFMFILE,N);
 OH:=M DIV 256;
 OL:=M MOD 256;
 WRITE(TFMFILE,OH);
 WRITE(TFMFILE,OL);

END;
 
PROCEDURE PARAMENTER;

BEGIN

 NAMELENGTH:=5;CURNAME[16]:=83;CURNAME[17]:=76;CURNAME[18]:=65;
 CURNAME[19]:=78;CURNAME[20]:=84;ENTERNAME(21);
 
 NAMELENGTH:=5;
 CURNAME[16]:=83;CURNAME[17]:=80;CURNAME[18]:=65;CURNAME[19]:=67;
 CURNAME[20]:=69;ENTERNAME(22);
 
 NAMELENGTH:=7;CURNAME[14]:=83;
 CURNAME[15]:=84;CURNAME[16]:=82;CURNAME[17]:=69;CURNAME[18]:=84;
 CURNAME[19]:=67;CURNAME[20]:=72;ENTERNAME(23);
 
 NAMELENGTH:=6;
 CURNAME[15]:=83;CURNAME[16]:=72;CURNAME[17]:=82;CURNAME[18]:=73;
 CURNAME[19]:=78;CURNAME[20]:=75;ENTERNAME(24);
 
 NAMELENGTH:=7;
 CURNAME[14]:=88;CURNAME[15]:=72;CURNAME[16]:=69;CURNAME[17]:=73;
 CURNAME[18]:=71;CURNAME[19]:=72;CURNAME[20]:=84;ENTERNAME(25);
 
 NAMELENGTH:=4;CURNAME[17]:=81;CURNAME[18]:=85;CURNAME[19]:=65;
 CURNAME[20]:=68;ENTERNAME(26);
 
 NAMELENGTH:=10;CURNAME[11]:=69;
 CURNAME[12]:=88;CURNAME[13]:=84;CURNAME[14]:=82;CURNAME[15]:=65;
 CURNAME[16]:=83;CURNAME[17]:=80;CURNAME[18]:=65;CURNAME[19]:=67;
 CURNAME[20]:=69;ENTERNAME(27);
 
 NAMELENGTH:=4;CURNAME[17]:=78;
 CURNAME[18]:=85;CURNAME[19]:=77;CURNAME[20]:=49;ENTERNAME(28);
 
 NAMELENGTH:=4;CURNAME[17]:=78;CURNAME[18]:=85;CURNAME[19]:=77;
 CURNAME[20]:=50;ENTERNAME(29);
 
 NAMELENGTH:=4;CURNAME[17]:=78;
 CURNAME[18]:=85;CURNAME[19]:=77;CURNAME[20]:=51;ENTERNAME(30);
 
 NAMELENGTH:=6;CURNAME[15]:=68;CURNAME[16]:=69;CURNAME[17]:=78;
 CURNAME[18]:=79;CURNAME[19]:=77;CURNAME[20]:=49;ENTERNAME(31);
 
 NAMELENGTH:=6;CURNAME[15]:=68;CURNAME[16]:=69;CURNAME[17]:= 78;
 CURNAME[18]:=79;CURNAME[19]:=77;CURNAME[20]:=50;ENTERNAME(32);
 
 NAMELENGTH:=4;CURNAME[17]:=83;CURNAME[18]:=85;CURNAME[19]:=80;
 CURNAME[20]:=49;ENTERNAME(33);
 
 NAMELENGTH:=4;CURNAME[17]:=83;
 CURNAME[18]:=85;CURNAME[19]:=80;CURNAME[20]:=50;ENTERNAME(34);
 NAMELENGTH:=4;CURNAME[17]:=83;CURNAME[18]:=85;CURNAME[19]:=80;
 CURNAME[20]:=51;ENTERNAME(35);NAMELENGTH:=4;CURNAME[17]:=83;
 CURNAME[18]:=85;CURNAME[19]:=66;CURNAME[20]:=49;ENTERNAME(36);
 NAMELENGTH:=4;CURNAME[17]:=83;CURNAME[18]:=85;CURNAME[19]:=66;
 CURNAME[20]:=50;ENTERNAME(37);NAMELENGTH:=7;CURNAME[14]:=83;
 CURNAME[15]:=85;CURNAME[16]:=80;CURNAME[17]:=68;CURNAME[18]:=82;
 CURNAME[19]:=79;CURNAME[20]:=80;ENTERNAME(38);NAMELENGTH:=7;
 CURNAME[14]:=83;CURNAME[15]:=85;CURNAME[16]:=66;CURNAME[17]:=68;
 CURNAME[18]:=82;CURNAME[19]:=79;CURNAME[20]:=80;ENTERNAME(39);
 NAMELENGTH:=6;CURNAME[15]:=68;CURNAME[16]:=69;CURNAME[17]:=76;
 CURNAME[18]:=73;CURNAME[19]:=77;CURNAME[20]:=49;ENTERNAME(40);
 NAMELENGTH:=6;CURNAME[15]:=68;CURNAME[16]:=69;CURNAME[17]:=76;
 CURNAME[18]:=73;CURNAME[19]:=77;CURNAME[20]:=50;ENTERNAME(41);
 NAMELENGTH:=10;CURNAME[11]:=65;CURNAME[12]:=88;CURNAME[13]:=73;
 CURNAME[14]:=83;CURNAME[15]:=72;CURNAME[16]:=69;CURNAME[17]:=73;
 CURNAME[18]:=71;CURNAME[19]:=72;CURNAME[20]:=84;ENTERNAME(42);
 NAMELENGTH:=20;CURNAME[1]:=68;CURNAME[2]:=69;CURNAME[3]:=70;
 CURNAME[4]:=65;CURNAME[5]:=85;CURNAME[6]:=76;CURNAME[7]:=84;
 CURNAME[8]:=82;CURNAME[9]:=85;CURNAME[10]:=76;CURNAME[11]:=69;
 CURNAME[12]:=84;CURNAME[13]:=72;CURNAME[14]:=73;CURNAME[15]:=67;
 CURNAME[16]:=75;CURNAME[17]:=78;CURNAME[18]:=69;CURNAME[19]:=83;
 CURNAME[20]:=83;ENTERNAME(28);NAMELENGTH:=13;CURNAME[8]:=66;
 CURNAME[9]:=73;CURNAME[10]:=71;CURNAME[11]:=79;CURNAME[12]:=80;
 CURNAME[13]:=83;CURNAME[14]:=80;CURNAME[15]:=65;CURNAME[16]:=67;
 CURNAME[17]:=73;CURNAME[18]:=78;CURNAME[19]:=71;CURNAME[20]:=49;
 ENTERNAME(29);NAMELENGTH:=13;CURNAME[8]:=66;CURNAME[9]:=73;
 CURNAME[10]:=71;CURNAME[11]:=79;CURNAME[12]:=80;CURNAME[13]:=83;
 CURNAME[14]:=80;CURNAME[15]:=65;CURNAME[16]:=67;CURNAME[17]:=73;
 CURNAME[18]:=78;CURNAME[19]:=71;CURNAME[20]:=50;ENTERNAME(30);
 NAMELENGTH:=13;CURNAME[8]:=66;CURNAME[9]:=73;CURNAME[10]:=71;
 CURNAME[11]:=79;CURNAME[12]:=80;CURNAME[13]:=83;CURNAME[14]:=80;
 CURNAME[15]:=65;CURNAME[16]:=67;CURNAME[17]:=73;CURNAME[18]:=78;
 CURNAME[19]:=71;CURNAME[20]:=51;ENTERNAME(31);NAMELENGTH:=13;
 CURNAME[8]:=66;CURNAME[9]:=73;CURNAME[10]:=71;CURNAME[11]:=79;
 CURNAME[12]:=80;CURNAME[13]:=83;CURNAME[14]:=80;CURNAME[15]:=65;
 CURNAME[16]:=67;CURNAME[17]:=73;CURNAME[18]:=78;CURNAME[19]:=71;
 CURNAME[20]:=52;ENTERNAME(32);NAMELENGTH:=13;CURNAME[8]:=66;
 CURNAME[9]:=73;CURNAME[10]:=71;CURNAME[11]:=79;CURNAME[12]:=80;
 CURNAME[13]:=83;CURNAME[14]:=80;CURNAME[15]:=65;CURNAME[16]:=67;
 CURNAME[17]:=73;CURNAME[18]:=78;CURNAME[19]:=71;CURNAME[20]:=53;
 ENTERNAME(33);{:48};
 
END;
 
PROCEDURE NAMEENTER;

BEGIN{47:}

 EQUIV[0]:=0;
 NAMELENGTH:=8;CURNAME[13]:=67;CURNAME[14]:=72;CURNAME[15]:=69;
 CURNAME[16]:=67;CURNAME[17]:=75;CURNAME[18]:=83;CURNAME[19]:=85;
 CURNAME[20]:=77;ENTERNAME(1);
 
 NAMELENGTH:=10;CURNAME[11]:=68;
 CURNAME[12]:=69;CURNAME[13]:=83;CURNAME[14]:=73;CURNAME[15]:=71;
 CURNAME[16]:=78;CURNAME[17]:=83;CURNAME[18]:=73;CURNAME[19]:=90;
 CURNAME[20]:=69;ENTERNAME(2);NAMELENGTH:=11;CURNAME[10]:=68;
 CURNAME[11]:=69;CURNAME[12]:=83;CURNAME[13]:=73;CURNAME[14]:=71;
 CURNAME[15]:=78;CURNAME[16]:=85;CURNAME[17]:=78;CURNAME[18]:=73;
 CURNAME[19]:=84;CURNAME[20]:=83;ENTERNAME(3);NAMELENGTH:=12;
 CURNAME[9]:=67;CURNAME[10]:=79;CURNAME[11]:=68;CURNAME[12]:=73;
 CURNAME[13]:=78;CURNAME[14]:=71;CURNAME[15]:=83;CURNAME[16]:=67;
 CURNAME[17]:=72;CURNAME[18]:=69;CURNAME[19]:=77;CURNAME[20]:=69;
 ENTERNAME(4);NAMELENGTH:=6;CURNAME[15]:=70;CURNAME[16]:=65;
 CURNAME[17]:=77;CURNAME[18]:=73;CURNAME[19]:=76;CURNAME[20]:=89;
 ENTERNAME(5);NAMELENGTH:=4;CURNAME[17]:=70;CURNAME[18]:=65;
 CURNAME[19]:=67;CURNAME[20]:=69;ENTERNAME(6);NAMELENGTH:=16;
 CURNAME[5]:=83;CURNAME[6]:=69;CURNAME[7]:=86;CURNAME[8]:=69;
 CURNAME[9]:=78;CURNAME[10]:=66;CURNAME[11]:=73;CURNAME[12]:=84;
 CURNAME[13]:=83;CURNAME[14]:=65;CURNAME[15]:=70;CURNAME[16]:=69;
 CURNAME[17]:=70;CURNAME[18]:=76;CURNAME[19]:=65;CURNAME[20]:=71;
 ENTERNAME(7);NAMELENGTH:=6;CURNAME[15]:=72;CURNAME[16]:=69;
 CURNAME[17]:=65;CURNAME[18]:=68;CURNAME[19]:=69;CURNAME[20]:=82;
 ENTERNAME(8);NAMELENGTH:=9;CURNAME[12]:=70;CURNAME[13]:=79;
 CURNAME[14]:=78;CURNAME[15]:=84;CURNAME[16]:=68;CURNAME[17]:=73;
 CURNAME[18]:=77;CURNAME[19]:=69;CURNAME[20]:=78;ENTERNAME(9);
 NAMELENGTH:=8;CURNAME[13]:=76;CURNAME[14]:=73;CURNAME[15]:=71;
 CURNAME[16]:=84;CURNAME[17]:=65;CURNAME[18]:=66;CURNAME[19]:=76;
 CURNAME[20]:=69;ENTERNAME(10);NAMELENGTH:=12;CURNAME[9]:=66;
 CURNAME[10]:=79;CURNAME[11]:=85;CURNAME[12]:=78;CURNAME[13]:=68;
 CURNAME[14]:=65;CURNAME[15]:=82;CURNAME[16]:=89;CURNAME[17]:=67;
 CURNAME[18]:=72;CURNAME[19]:=65;CURNAME[20]:=82;ENTERNAME(11);
 
 NAMELENGTH:=9;CURNAME[12]:=67;CURNAME[13]:=72;CURNAME[14]:=65;
 CURNAME[15]:=82;CURNAME[16]:=65;CURNAME[17]:=67;CURNAME[18]:=84;
 CURNAME[19]:=69;CURNAME[20]:=82;ENTERNAME(12);
 
 NAMELENGTH:=9;
 CURNAME[12]:=80;CURNAME[13]:=65;CURNAME[14]:=82;CURNAME[15]:=65;
 CURNAME[16]:=77;CURNAME[17]:=69;CURNAME[18]:=84;CURNAME[19]:=69;
 CURNAME[20]:=82;ENTERNAME(20);
 
 NAMELENGTH:=6;CURNAME[15]:=67;
 CURNAME[16]:=72;CURNAME[17]:=65;CURNAME[18]:=82;CURNAME[19]:=87;
 CURNAME[20]:=68;ENTERNAME(51);NAMELENGTH:=6;CURNAME[15]:=67;
 CURNAME[16]:=72;CURNAME[17]:=65;CURNAME[18]:=82;CURNAME[19]:=72;
 CURNAME[20]:=84;ENTERNAME(52);NAMELENGTH:=6;CURNAME[15]:=67;
 CURNAME[16]:=72;CURNAME[17]:=65;CURNAME[18]:=82;CURNAME[19]:=68;
 CURNAME[20]:=80;ENTERNAME(53);NAMELENGTH:=6;CURNAME[15]:=67;
 CURNAME[16]:=72;CURNAME[17]:=65;CURNAME[18]:=82;CURNAME[19]:=73;
 CURNAME[20]:=67;ENTERNAME(54);NAMELENGTH:=10;CURNAME[11]:=78;
 CURNAME[12]:=69;CURNAME[13]:=88;CURNAME[14]:=84;CURNAME[15]:=76;
 CURNAME[16]:=65;CURNAME[17]:=82;CURNAME[18]:=71;CURNAME[19]:=69;
 CURNAME[20]:=82;ENTERNAME(55);NAMELENGTH:=7;CURNAME[14]:=86;
 CURNAME[15]:=65;CURNAME[16]:=82;CURNAME[17]:=67;CURNAME[18]:=72;
 CURNAME[19]:=65;CURNAME[20]:=82;ENTERNAME(56);NAMELENGTH:=3;
 CURNAME[18]:=84;CURNAME[19]:=79;CURNAME[20]:=80;ENTERNAME(57);
 NAMELENGTH:=3;CURNAME[18]:=77;CURNAME[19]:=73;CURNAME[20]:=68;
 ENTERNAME(58);NAMELENGTH:=3;CURNAME[18]:=66;CURNAME[19]:=79;
 CURNAME[20]:=84;ENTERNAME(59);NAMELENGTH:=3;CURNAME[18]:=82;
 CURNAME[19]:=69;CURNAME[20]:=80;ENTERNAME(60);NAMELENGTH:=3;
 CURNAME[18]:=69;CURNAME[19]:=88;CURNAME[20]:=84;ENTERNAME(60);
 NAMELENGTH:=7;CURNAME[14]:=67;CURNAME[15]:=79;CURNAME[16]:=77;
 CURNAME[17]:=77;CURNAME[18]:=69;CURNAME[19]:=78;CURNAME[20]:=84;
 ENTERNAME(0);NAMELENGTH:=5;CURNAME[16]:=76;CURNAME[17]:=65;
 CURNAME[18]:=66;CURNAME[19]:=69;CURNAME[20]:=76;ENTERNAME(70);
 NAMELENGTH:=4;CURNAME[17]:=83;CURNAME[18]:=84;CURNAME[19]:=79;
 CURNAME[20]:=80;ENTERNAME(71);NAMELENGTH:=4;CURNAME[17]:=83;
 CURNAME[18]:=75;CURNAME[19]:=73;CURNAME[20]:=80;ENTERNAME(72);
 NAMELENGTH:=3;CURNAME[18]:=75;CURNAME[19]:=82;CURNAME[20]:=78;
 ENTERNAME(73);NAMELENGTH:=3;CURNAME[18]:=76;CURNAME[19]:=73;
 CURNAME[20]:=71;ENTERNAME(74);NAMELENGTH:=4;CURNAME[17]:=47;
 CURNAME[18]:=76;CURNAME[19]:=73;CURNAME[20]:=71;ENTERNAME(76);
 NAMELENGTH:=5;CURNAME[16]:=47;CURNAME[17]:=76;CURNAME[18]:=73;
 CURNAME[19]:=71;CURNAME[20]:=62;ENTERNAME(80);NAMELENGTH:=4;
 CURNAME[17]:=76;CURNAME[18]:=73;CURNAME[19]:=71;CURNAME[20]:=47;
 ENTERNAME(75);NAMELENGTH:=5;CURNAME[16]:=76;CURNAME[17]:=73;
 CURNAME[18]:=71;CURNAME[19]:=47;CURNAME[20]:=62;ENTERNAME(79);
 NAMELENGTH:=5;CURNAME[16]:=47;CURNAME[17]:=76;CURNAME[18]:=73;
 CURNAME[19]:=71;CURNAME[20]:=47;ENTERNAME(77);NAMELENGTH:=6;
 CURNAME[15]:=47;CURNAME[16]:=76;CURNAME[17]:=73;CURNAME[18]:=71;
 CURNAME[19]:=47;CURNAME[20]:=62;ENTERNAME(81);NAMELENGTH:=7;
 CURNAME[14]:=47;CURNAME[15]:=76;CURNAME[16]:=73;CURNAME[17]:=71;
 CURNAME[18]:=47;CURNAME[19]:=62;CURNAME[20]:=62;ENTERNAME(85);{:47};
 PARAMENTER;
 
END;

PROCEDURE READLIGKERN;

VAR     KRNPTR:SHORT;
        C:SHORT;

BEGIN

 BEGIN
  WHILE LEVEL=1 DO BEGIN
   WHILE CURCHAR=32 DO
    GETNEXT;
   IF CURCHAR=40 THEN BEGIN
    GETNAME;
    IF CURCODE=0 THEN
     SKIPTOENDOFI
    ELSE IF CURCODE<70 THEN BEGIN
     BEGIN
      IF CHARSONLINE>0 THEN WRITELN(' ');
      WRITE('This property name doesn\'t belong in a LIGTABLE list');
      SHOWERRORCON;
     END;
     SKIPTOENDOFI;
    END ELSE BEGIN
     CASE CURCODE OF
      70: BEGIN
       WHILE CURCHAR=32 DO
        GETNEXT;
       IF CURCHAR=66 THEN BEGIN
        CHARREMAINDE[256]:=NL;
        REPEAT
         GETNEXT
        UNTIL(CURCHAR=40)OR(CURCHAR=41);
       END ELSE BEGIN
        BEGIN
         IF(CURCHAR>41)OR(CURCHAR<40)THEN
          LOC:=LOC-1;
        END;
        C:=GETBYTE;
        CHECKTAG(C);
        CHARTAG[C]:=1;
        CHARREMAINDE[C]:=NL;
       END;
       IF MINNL<=NL THEN
        MINNL:=NL+1;
       LKSTEPENDED:=FALSE;
      END;
      71:
       IF NOT LKSTEPENDED THEN BEGIN
        IF CHARSONLINE>0 THEN WRITELN(' ');
        WRITE('STOP must follow LIG or KRN');
        SHOWERRORCON;
       END ELSE BEGIN 
        LIGKERN[NL-1].B0:=128;
        LKSTEPENDED:=FALSE;
       END;
      72:
       IF NOT LKSTEPENDED THEN BEGIN
        IF CHARSONLINE>0 THEN WRITELN(' ');
        WRITE('SKIP must follow LIG or KRN');
        SHOWERRORCON;
       END ELSE BEGIN
        C:=GETBYTE;
        IF C>=128 THEN BEGIN
         IF CHARSONLINE>0 THEN WRITELN(' ');
         WRITE('Maximum SKIP amount is 127');
         SHOWERRORCON;
        END ELSE IF NL+C>=MAXLIGSTEPS THEN BEGIN
         IF CHARSONLINE>0 THEN WRITELN(' ');
         WRITE('Sorry, LIGTABLE too long for me to handle');
         SHOWERRORCON;
        END ELSE BEGIN
         LIGKERN[NL-1].B0:=C;
         IF MINNL<=NL+C THEN MINNL:=NL+C+1;
        END;
        LKSTEPENDED:=FALSE;
       END;
      73: BEGIN
       LIGKERN[NL].B0:=0;
       LIGKERN[NL].B1:=GETBYTE;
       KERN[NK]:=GETFIX;
       KRNPTR:=0;
       WHILE KERN[KRNPTR]<>KERN[NK]DO
        KRNPTR:=KRNPTR+1;
       IF KRNPTR=NK THEN BEGIN
        IF NK<MAXKERNS THEN
         NK:=NK+1
        ELSE BEGIN
         BEGIN
          IF CHARSONLINE>0 THEN WRITELN(' ');
          WRITE('Sorry, too many different kerns for me to handle');
          SHOWERRORCON;
         END;
         KRNPTR:=KRNPTR-1;
        END;
       END;
       LIGKERN[NL].B2:=128+(KRNPTR DIV 256);
       LIGKERN[NL].B3:=KRNPTR MOD 256;
       IF NL>=MAXLIGSTEPS-1 THEN BEGIN
        IF CHARSONLINE>0 THEN WRITELN(' ');
        WRITE('Sorry, LIGTABLE too long for me to handle');
        SHOWERRORCON;
       END ELSE
        NL:=NL+1;
       LKSTEPENDED:=TRUE;
      END;
      74,75,76,77,79,80,81,85: BEGIN
       LIGKERN[NL].B0:=0;
       LIGKERN[NL].B2:=CURCODE-74;
       LIGKERN[NL].B1:=GETBYTE;
       LIGKERN[NL].B3:=GETBYTE;
       IF NL>=MAXLIGSTEPS-1 THEN BEGIN
        IF CHARSONLINE>0 THEN WRITELN(' ');
        WRITE('Sorry, LIGTABLE too long for me to handle');
        SHOWERRORCON;
       END ELSE
        NL:=NL+1;
       LKSTEPENDED:=TRUE;
      END;
     END;
     FINISHTHEPRO;
    END;
   END ELSE IF CURCHAR=41 THEN 
    SKIPTOENDOFI
   ELSE 
    JUNKERROR;
  END;
  BEGIN
   LOC:=LOC-1;
   LEVEL:=LEVEL+1;
   CURCHAR:=41;
  END;
 END;
END;

PROCEDURE READCHARINFO;

VAR     C:SHORT;

BEGIN

 BEGIN
  C:=GETBYTE;
  BEGIN
   IF CHARSONLINE=8 THEN BEGIN
    WRITELN(' ');
    CHARSONLINE:=1;
   END ELSE BEGIN
    IF CHARSONLINE>0 THEN WRITE(' ');
    CHARSONLINE:=CHARSONLINE+1;
   END;
   PRINTOCTAL(C);
  END;
  WHILE LEVEL=1 DO BEGIN
   WHILE CURCHAR=32 DO
    GETNEXT;
   IF CURCHAR=40 THEN BEGIN
    GETNAME;
    IF CURCODE=0 THEN
     SKIPTOENDOFI
    ELSE IF(CURCODE<51)OR(CURCODE>56)THEN BEGIN
     BEGIN
      IF CHARSONLINE>0 THEN WRITELN(' ');
      WRITE('This property name doesn\'t belong in a CHARACTER list');
      SHOWERRORCON;
     END;
     SKIPTOENDOFI;
    END ELSE BEGIN
     CASE CURCODE OF
      51:CHARWD[C]:=SORTIN(1,GETFIX);
      52:CHARHT[C]:=SORTIN(2,GETFIX);
      53:CHARDP[C]:=SORTIN(3,GETFIX);
      54:CHARIC[C]:=SORTIN(4,GETFIX);
      55:BEGIN
       CHECKTAG(C);
       CHARTAG[C]:=2;
       CHARREMAINDE[C]:=GETBYTE;
      END;
      56:BEGIN
       IF NE=256 THEN BEGIN
        IF CHARSONLINE>0 THEN WRITELN(' ');
        WRITE('At most 256 VARCHAR specs are allowed');
        SHOWERRORCON;
       END ELSE BEGIN
        CHECKTAG(C);
        CHARTAG[C]:=3;
        CHARREMAINDE[C]:=NE;
        EXTEN[NE].B0:=0;
        EXTEN[NE].B1:=0;
        EXTEN[NE].B2:=0;
        EXTEN[NE].B3:=0;
        WHILE LEVEL=2 DO BEGIN 
         WHILE CURCHAR=32 DO 
          GETNEXT;
         IF CURCHAR=40 THEN BEGIN
          GETNAME;
          IF CURCODE=0 THEN 
           SKIPTOENDOFI 
          ELSE IF(CURCODE<57)OR(CURCODE>60)THEN BEGIN
           BEGIN
            IF CHARSONLINE>0 THEN WRITELN(' ');
            WRITE('This property name doesn\'t belong in a VARCHAR list');
            SHOWERRORCON;
           END;
           SKIPTOENDOFI;
          END ELSE BEGIN
           CASE CURCODE-(57)OF
            0:EXTEN[NE].B0:=GETBYTE;
            1:EXTEN[NE].B1:=GETBYTE;
            2:EXTEN[NE].B2:=GETBYTE;
            3:EXTEN[NE].B3:=GETBYTE;
           END;
           FINISHTHEPRO;
          END;
         END ELSE IF CURCHAR=41 THEN
          SKIPTOENDOFI
         ELSE 
          JUNKERROR;
        END;
        NE:=NE+1;
        BEGIN
         LOC:=LOC-1;
         LEVEL:=LEVEL+1;
         CURCHAR:=41;
        END;
       END;
      END;
     END;
     FINISHTHEPRO;
    END;
   END ELSE IF CURCHAR=41 THEN
    SKIPTOENDOFI
   ELSE
    JUNKERROR;
  END;
  IF CHARWD[C]=0 THEN 
   CHARWD[C]:=SORTIN(1,0);
  BEGIN
   LOC:=LOC-1;
   LEVEL:=LEVEL+1;
   CURCHAR:=41;
  END;
 END;
END;

PROCEDURE READINPUT;

VAR     C:SHORT;

BEGIN

 CURCHAR:=32;
 REPEAT WHILE CURCHAR=32 DO 
  GETNEXT;
  IF CURCHAR=40 THEN BEGIN
   GETNAME; 
   IF CURCODE=0 THEN
    SKIPTOENDOFI
   ELSE IF CURCODE>12 THEN BEGIN
    BEGIN
     IF CHARSONLINE>0 THEN WRITELN(' ');
     WRITE('This property name doesn\'t belong on the outer level');
     SHOWERRORCON;
    END;
    SKIPTOENDOFI;
   END ELSE BEGIN
    CASE CURCODE OF
     1:BEGIN
      CHECKSUMSPEC:=TRUE;
      READFOURBYTE(0);
     END;
     2:BEGIN
      NEXTD:=GETFIX;
      IF NEXTD<1048576 THEN BEGIN
       IF CHARSONLINE>0 THEN WRITELN(' ');
       WRITE('The design size must be at least 1');
       SHOWERRORCON;
      END ELSE 
       DESIGNSIZE:=NEXTD;
     END;
     3:BEGIN 
      NEXTD:=GETFIX;
      IF NEXTD<=0 THEN BEGIN
       IF CHARSONLINE>0 THEN WRITELN(' ');
       WRITE('The number of units per design size must be positive');
       SHOWERRORCON;
      END ELSE
       DESIGNUNITS:=NEXTD;
     END;
     4:READBCPL(8,40);
     5:READBCPL(48,20);
     6:HEADERBYTES[71]:=GETBYTE;
     7:BEGIN
      WHILE CURCHAR=32 DO
       GETNEXT;
      IF CURCHAR=84 THEN
       SEVENBITSAFE:=TRUE
      ELSE IF CURCHAR=70 THEN
       SEVENBITSAFE:=FALSE
      ELSE BEGIN
       IF CHARSONLINE>0 THEN WRITELN(' ');
       WRITE('The flag value should be "TRUE" or "FALSE"');
       SHOWERRORCON;
      END;
      REPEAT
       GETNEXT
      UNTIL(CURCHAR=40)OR(CURCHAR=41);
     END;
     8:BEGIN
      C:=GETBYTE;
      IF C<18 THEN BEGIN
       BEGIN
        IF CHARSONLINE>0 THEN WRITELN(' ');
        WRITE('HEADER indices should be 18 or more');
        SHOWERRORCON;
       END;
       REPEAT
        GETNEXT
       UNTIL(CURCHAR=40)OR(CURCHAR=41);
      END ELSE IF 4*C+4>MAXHEADERBYT THEN BEGIN
       BEGIN
        IF CHARSONLINE>0 THEN WRITELN(' ');
        WRITE('This HEADER index is too big for my present table size');
        SHOWERRORCON;
       END;
       REPEAT
        GETNEXT
       UNTIL(CURCHAR=40)OR(CURCHAR=41);
      END ELSE BEGIN
       WHILE HEADERPTR<4*C+4 DO BEGIN
        HEADERBYTES[HEADERPTR]:=0;
        HEADERPTR:=HEADERPTR+1;
       END;
       READFOURBYTE(4*C);
      END;
     END;
     9:BEGIN
      WHILE LEVEL=1 DO BEGIN
       WHILE CURCHAR=32 DO
        GETNEXT;
       IF CURCHAR=40 THEN BEGIN
        GETNAME;
        IF CURCODE=0 THEN
         SKIPTOENDOFI
        ELSE IF(CURCODE<20)OR(CURCODE>=51)THEN BEGIN
         BEGIN
          IF CHARSONLINE>0 THEN WRITELN(' ');
          WRITE('This property name doesn\'t belong in a FONTDIMEN list');
          SHOWERRORCON;
         END;
         SKIPTOENDOFI;
        END ELSE BEGIN
         IF CURCODE=20 THEN
          C:=GETBYTE
         ELSE
          C:=CURCODE-20;
         IF C=0 THEN BEGIN
          BEGIN
           IF CHARSONLINE>0 THEN WRITELN(' ');
           WRITE('PARAMETER index must not be zero');
           SHOWERRORCON;
          END;
          SKIPTOENDOFI;
         END ELSE IF C>MAXPARAMWORD THEN BEGIN
          BEGIN
           IF CHARSONLINE>0 THEN WRITELN(' ');
           WRITE('This PARAMETER index is too big for my present table size');
           SHOWERRORCON;
          END;
          SKIPTOENDOFI;
         END ELSE BEGIN
          WHILE NP<C DO BEGIN 
           NP:=NP+1;
           PARAM[NP]:=0;
          END;
          PARAM[C]:=GETFIX;
          FINISHTHEPRO;
         END;
        END;
       END ELSE IF CURCHAR=41 THEN
        SKIPTOENDOFI
       ELSE 
        JUNKERROR;
      END;
      BEGIN
       LOC:=LOC-1;
       LEVEL:=LEVEL+1;
       CURCHAR:=41;
      END;
     END;
     10:READLIGKERN;
     11:BCHAR:=GETBYTE;
     12:READCHARINFO;
    END;
    FINISHTHEPRO;
   END;
  END ELSE IF (CURCHAR=41) AND NOT INPUTHASENDE THEN BEGIN
   BEGIN
    IF CHARSONLINE>0 THEN WRITELN(' ');
    WRITE('Extra right parenthesis');
    SHOWERRORCON;
   END;
   LOC:=LOC+1;
   CURCHAR:=32;
  END ELSE IF NOT INPUTHASENDE THEN BEGIN
   JUNKERROR;
  END;
UNTIL INPUTHASENDE;
 
END;

PROCEDURE CCDELTA;
 
 {A few lines removed from CORRANDCHECK, because CORRANDCHECK was too
  long for PCQ Pascal}

BEGIN

 DELTA:=SHORTEN(1,255);
 SETINDICES(1,DELTA);
 IF DELTA>0 THEN 
  WRITELN('I had to round some ','width','s by ',(((DELTA+1)DIV 2)/1048576):1:7,' units.');
 DELTA:=SHORTEN(2,15);
 SETINDICES(2,DELTA);
 IF DELTA>0 THEN
  WRITELN('I had to round some ','height','s by ',(((DELTA+1)DIV 2)/1048576):1:7,' units.');
 DELTA:=SHORTEN(3,15);
 SETINDICES(3,DELTA);
 IF DELTA>0 THEN 
  WRITELN('I had to round some ','depth','s by ',(((DELTA+1)DIV 2)/1048576):1:7,' units.');
 DELTA:=SHORTEN(4,63);
 SETINDICES(4,DELTA);
 IF DELTA>0 THEN 
  WRITELN('I had to round some ','italic correction','s by ',(((DELTA+1)DIV 2)/1048576):1:7,' units.');

END;

PROCEDURE CORRANDCHECK;

VAR     C:SHORT; {Originally 0..256}
        HH:SHORT;
        LIGPTR:SHORT;
        G:SHORT;
        
BEGIN

 IF NL>0 THEN BEGIN 
  IF CHARREMAINDE[256]<32767 THEN BEGIN 
   LIGKERN[NL].B0:=255;
   LIGKERN[NL].B1:=0;
   LIGKERN[NL].B2:=0;
   LIGKERN[NL].B3:=0;
   NL:=NL+1;
  END;
  WHILE MINNL>NL DO BEGIN 
   LIGKERN[NL].B0:=255;
   LIGKERN[NL].B1:=0;
   LIGKERN[NL].B2:=0;
   LIGKERN[NL].B3:=0;
   NL:=NL+1;
  END;
  IF LIGKERN[NL-1].B0=0 THEN 
   LIGKERN[NL-1].B0:=128;
 END;
 SEVENUNSAFE:=FALSE;
 FOR C:=0 TO 255 DO
  IF CHARWD[C]<>0 THEN
   CASE CHARTAG[C]OF
    0:;
    1:BEGIN
     LIGPTR:=CHARREMAINDE[C];
     REPEAT
      IF HASHINPUT(LIGPTR,C)THEN BEGIN
       IF LIGKERN[LIGPTR].B2<128 THEN BEGIN
        IF LIGKERN[LIGPTR].B1<>BCHAR THEN BEGIN
         G:=LIGKERN[LIGPTR].B1;
         IF CHARWD[G]=0 THEN BEGIN
          CHARWD[G]:=SORTIN(1,0);
          WRITE('LIG character examined by',' ');
          PRINTOCTAL(C);
          WRITELN(' had no CHARACTER spec.');
         END;
        END;
        BEGIN
         G:=LIGKERN[LIGPTR].B3;
         IF CHARWD[G]=0 THEN BEGIN 
          CHARWD[G]:=SORTIN(1,0);
          WRITE('LIG character generated by',' ');
          PRINTOCTAL(C);
          WRITELN(' had no CHARACTER spec.');
         END;
        END;
        IF LIGKERN[LIGPTR].B3>=128 THEN 
         IF(C<128)OR(C=256)THEN
          IF(LIGKERN[LIGPTR].B1<128)OR(LIGKERN[LIGPTR].B1=BCHAR)THEN
           SEVENUNSAFE:=TRUE;
       END ELSE IF LIGKERN[LIGPTR].B1<>BCHAR THEN BEGIN
        G:=LIGKERN[LIGPTR].B1;
        IF CHARWD[G]=0 THEN BEGIN
         CHARWD[G]:=SORTIN(1,0);
         WRITE('KRN character examined by',' ');
         PRINTOCTAL(C);
         WRITELN(' had no CHARACTER spec.');
        END;
       END;
      END;
      IF LIGKERN[LIGPTR].B0>=128 THEN
       LIGPTR:=NL
      ELSE
       LIGPTR:=LIGPTR+1+LIGKERN[LIGPTR].B0;
     UNTIL LIGPTR>=NL;
    END;
    2:BEGIN
     G:=CHARREMAINDE[C];
     IF(G>=128)AND(C<128)THEN
      SEVENUNSAFE:=TRUE;
     IF CHARWD[G]=0 THEN BEGIN 
      CHARWD[G]:=SORTIN(1,0);
      WRITE('The character NEXTLARGER than',' ');
      PRINTOCTAL(C);
      WRITELN(' had no CHARACTER spec.');
     END;
    END;
    3:BEGIN
     IF EXTEN[CHARREMAINDE[C]].B0>0 THEN BEGIN
      G:=EXTEN[CHARREMAINDE[C]].B0;
      IF(G>=128)AND(C<128)THEN
       SEVENUNSAFE:=TRUE;
      IF CHARWD[G]=0 THEN BEGIN
       CHARWD[G]:=SORTIN(1,0);
       WRITE('TOP piece of character',' ');
       PRINTOCTAL(C);
       WRITELN(' had no CHARACTER spec.');
      END;
     END;
     IF EXTEN[CHARREMAINDE[C]].B1>0 THEN BEGIN
      G:=EXTEN[CHARREMAINDE[C]].B1;
      IF(G>=128)AND(C<128)THEN
       SEVENUNSAFE:=TRUE;
       IF CHARWD[G]=0 THEN BEGIN
        CHARWD[G]:=SORTIN(1,0);
        WRITE('MID piece of character',' ');
        PRINTOCTAL(C);
        WRITELN(' had no CHARACTER spec.');
       END;
      END;
      IF EXTEN[CHARREMAINDE[C]].B2>0 THEN BEGIN
       G:=EXTEN[CHARREMAINDE[C]].B2;
       IF(G>=128)AND(C<128)THEN 
        SEVENUNSAFE:=TRUE;
       IF CHARWD[G]=0 THEN BEGIN 
        CHARWD[G]:=SORTIN(1,0);
       WRITE('BOT piece of character',' ');
       PRINTOCTAL(C);
       WRITELN(' had no CHARACTER spec.');
      END;
     END;
     BEGIN
      G:=EXTEN[CHARREMAINDE[C]].B3;
      IF(G>=128)AND(C<128)THEN
       SEVENUNSAFE:=TRUE;
      IF CHARWD[G]=0 THEN BEGIN
       CHARWD[G]:=SORTIN(1,0);
       WRITE('REP piece of character',' ');
       PRINTOCTAL(C);
       WRITELN(' had no CHARACTER spec.');
      END;
     END;
    END;
   END;
   IF CHARREMAINDE[256]<32767 THEN BEGIN
    C:=256;
    BEGIN
     LIGPTR:=CHARREMAINDE[C];
     REPEAT
      IF HASHINPUT(LIGPTR,C)THEN BEGIN
       IF LIGKERN[LIGPTR].B2<128 THEN BEGIN
        IF LIGKERN[LIGPTR].B1<>BCHAR THEN BEGIN
         G:=LIGKERN[LIGPTR].B1;
         IF CHARWD[G]=0 THEN BEGIN
          CHARWD[G]:=SORTIN(1,0);
          WRITE('LIG character examined by',' ');
          PRINTOCTAL(C);
          WRITELN(' had no CHARACTER spec.');
         END;
        END;
        BEGIN
         G:=LIGKERN[LIGPTR].B3;
         IF CHARWD[G]=0 THEN BEGIN
          CHARWD[G]:=SORTIN(1,0);
          WRITE('LIG character generated by',' ');
          PRINTOCTAL(C);
          WRITELN(' had no CHARACTER spec.');
         END;
        END;
        IF LIGKERN[LIGPTR].B3>=128 THEN 
         IF(C<128)OR(C=256)THEN
          IF(LIGKERN[LIGPTR].B1<128)OR(LIGKERN[LIGPTR].B1=BCHAR)THEN
           SEVENUNSAFE:=TRUE;
       END ELSE IF LIGKERN[LIGPTR].B1<>BCHAR THEN BEGIN
        G:=LIGKERN[LIGPTR].B1;
        IF CHARWD[G]=0 THEN BEGIN
         CHARWD[G]:=SORTIN(1,0);
         WRITE('KRN character examined by',' ');
         PRINTOCTAL(C);
         WRITELN(' had no CHARACTER spec.');
        END;
       END;
      END;
      IF LIGKERN[LIGPTR].B0>=128 THEN
       LIGPTR:=NL
      ELSE
       LIGPTR:=LIGPTR+1+LIGKERN[LIGPTR].B0;
     UNTIL LIGPTR>=NL;
    END;
   END;
   IF SEVENBITSAFE AND SEVENUNSAFE THEN 
    WRITELN('The font is not really seven-bit-safe!');
   IF HASHPTR<5003 THEN
    FOR HH:=1 TO HASHPTR DO BEGIN
     TT:=HASHLIST[HH];
     IF CLASS[TT]>0 THEN
      TT:=F(TT,(PLHASH[TT]-1)DIV 256,(PLHASH[TT]-1)MOD 256);
    END;
    IF(HASHPTR=5003)OR(YLIGCYCLE<256)THEN BEGIN
     IF HASHPTR<5003 THEN BEGIN
      WRITE('Infinite ligature loop starting with ');
      IF XLIGCYCLE=256 THEN 
       WRITE('boundary')
      ELSE 
       PRINTOCTAL(XLIGCYCLE);
      WRITE(' and ');
      PRINTOCTAL(YLIGCYCLE);
      WRITELN('!');
     END ELSE 
      WRITELN('Sorry, I haven\'t room for so many ligature/kern pairs!');
     WRITELN('All ligatures will be cleared.');
     FOR C:=0 TO 255 DO
      IF CHARTAG[C]=1 THEN BEGIN 
       CHARTAG[C]:=0;
       CHARREMAINDE[C]:=0;
      END;
     NL:=0;
     BCHAR:=256;
     CHARREMAINDE[256]:=32767;
    END;
    IF NL>0 THEN
     FOR LIGPTR:=0 TO NL-1 DO
      IF LIGKERN[LIGPTR].B2<128 THEN BEGIN
       IF LIGKERN[LIGPTR].B0<255 THEN BEGIN 
        BEGIN 
         C:=LIGKERN[LIGPTR].B1;
         IF CHARWD[C]=0 THEN 
          IF C<>BCHAR THEN BEGIN 
           LIGKERN[LIGPTR].B1:=0;
           IF CHARWD[0]=0 THEN  
            CHARWD[0]:=SORTIN(1,0);
           WRITE('Unused ','LIG step',' refers to nonexistent character ');
           PRINTOCTAL(C);
           WRITELN('!');
          END;
        END;
        BEGIN 
         C:=LIGKERN[LIGPTR].B3;
         IF CHARWD[C]=0 THEN 
          IF C<>BCHAR THEN BEGIN 
           LIGKERN[LIGPTR].B3:=0;
           IF CHARWD[0]=0 THEN 
            CHARWD[0]:=SORTIN(1,0);
           WRITE('Unused ','LIG step',' refers to nonexistent character ');
           PRINTOCTAL(C);
           WRITELN('!');
          END;
        END;
       END;
      END ELSE BEGIN 
       C:=LIGKERN[LIGPTR].B1;
       IF CHARWD[C]=0 THEN 
        IF C<>BCHAR THEN BEGIN 
         LIGKERN[LIGPTR].B1:=0;
         IF CHARWD[0]=0 THEN 
          CHARWD[0]:=SORTIN(1,0);
          WRITE('Unused ','KRN step',' refers to nonexistent character ');
          PRINTOCTAL(C);
          WRITELN('!');
        END;
      END;
      IF NE>0 THEN
       FOR G:=0 TO NE-1 DO BEGIN 
        BEGIN 
         C:=EXTEN[G].B0;
         IF C>0 THEN 
          IF CHARWD[C]=0 THEN BEGIN 
           EXTEN[G].B0:=0;
           IF CHARWD[0]=0 THEN 
            CHARWD[0]:=SORTIN(1,0);
           WRITE('Unused ','VARCHAR TOP',' refers to nonexistent character ');
           PRINTOCTAL(C);
           WRITELN('!');
          END;
        END;
        BEGIN 
         C:=EXTEN[G].B1;
         IF C>0 THEN 
          IF CHARWD[C]=0 THEN BEGIN 
           EXTEN[G].B1:=0;
           IF CHARWD[0]=0 THEN 
            CHARWD[0]:=SORTIN(1,0);
           WRITE('Unused ','VARCHAR MID',' refers to nonexistent character ');
           PRINTOCTAL(C);
           WRITELN('!');
          END;
        END;
        BEGIN 
         C:=EXTEN[G].B2;
         IF C>0 THEN IF CHARWD[C]=0 THEN BEGIN 
          EXTEN[G].B2:=0;
          IF CHARWD[0]=0 THEN 
           CHARWD[0]:=SORTIN(1,0);
          WRITE('Unused ','VARCHAR BOT',' refers to nonexistent character ');
          PRINTOCTAL(C);
          WRITELN('!');
         END;
        END;
        BEGIN 
         C:=EXTEN[G].B3;
         IF CHARWD[C]=0 THEN BEGIN 
          EXTEN[G].B3:=0;
          IF CHARWD[0]=0 THEN 
           CHARWD[0]:=SORTIN(1,0);
           WRITE('Unused ','VARCHAR REP',' refers to nonexistent character ');
           PRINTOCTAL(C);
           WRITELN('!');
         END;
        END;
       END;
       FOR C:=0 TO 255 DO
        IF CHARTAG[C]=2 THEN BEGIN 
         G:=CHARREMAINDE[C];
         WHILE(G<C)AND(CHARTAG[G]=2)DO 
          G:=CHARREMAINDE[G];
         IF G=C THEN BEGIN 
          CHARTAG[C]:=0;
          WRITE('A cycle of NEXTLARGER characters has been broken at ');
          PRINTOCTAL(C);
          WRITELN('.');
         END;
        END;

 CCDELTA; {A few lines removed from this procedure, because this
           procedure is too long for PCQ Pascal}

END;

BEGIN 
 
 INITIALIZE;
 NAMEENTER;
 READINPUT;
 WRITELN('.');
 CORRANDCHECK;
 LH:=HEADERPTR DIV 4;
 NOTFOUND:=TRUE;
 BC:=0;
 WHILE NOTFOUND DO 
  IF(CHARWD[BC]>0)OR(BC=255)THEN 
   NOTFOUND:=FALSE 
  ELSE 
   BC:=BC+1;
 NOTFOUND:=TRUE;
 EC:=255;
 WHILE NOTFOUND DO 
  IF(CHARWD[EC]>0)OR(EC=0)THEN 
   NOTFOUND:=FALSE 
  ELSE 
   EC:=EC-1;
 IF BC>EC THEN 
  BC:=1;
 MEMORY[1]:=MEMORY[1]+1;
 MEMORY[2]:=MEMORY[2]+1;
 MEMORY[3]:=MEMORY[3]+1;
 MEMORY[4]:=MEMORY[4]+1;
 LABELPTR:=0;
 LABELTABLE[0].RR:=-1;
 FOR C:=BC TO EC DO 
  IF CHARTAG[C]=1 THEN BEGIN 
   SORTPTR:=LABELPTR;
   WHILE LABELTABLE[SORTPTR].RR>CHARREMAINDE[C]DO BEGIN 
    LABELTABLE[SORTPTR+1]:=LABELTABLE[SORTPTR];
    SORTPTR:=SORTPTR-1;
   END;
   LABELTABLE[SORTPTR+1].CC:=C;
   LABELTABLE[SORTPTR+1].RR:=CHARREMAINDE[C];
   LABELPTR:=LABELPTR+1;
  END;
 IF BCHAR<256 THEN BEGIN 
  EXTRALOCNEED:=TRUE;
  LKOFFSET:=1;
 END ELSE BEGIN 
  EXTRALOCNEED:=FALSE;
  LKOFFSET:=0;
 END;
 BEGIN 
  SORTPTR:=LABELPTR;
  IF LABELTABLE[SORTPTR].RR+LKOFFSET>255 THEN BEGIN 
   LKOFFSET:=0;
   EXTRALOCNEED:=FALSE;
   REPEAT 
    CHARREMAINDE[LABELTABLE[SORTPTR].CC]:=LKOFFSET;
    WHILE LABELTABLE[SORTPTR-1].RR=LABELTABLE[SORTPTR].RR DO BEGIN 
     SORTPTR:=SORTPTR-1;
     CHARREMAINDE[LABELTABLE[SORTPTR].CC]:=LKOFFSET;
    END;
    LKOFFSET:=LKOFFSET+1;
    SORTPTR:=SORTPTR-1;
   UNTIL LKOFFSET+LABELTABLE[SORTPTR].RR<256;
  END;
  IF LKOFFSET>0 THEN 
   WHILE SORTPTR>0 DO BEGIN 
    CHARREMAINDE[LABELTABLE[SORTPTR].CC]:=CHARREMAINDE[LABELTABLE[SORTPTR].CC]+LKOFFSET;
    SORTPTR:=SORTPTR-1;
   END;
 END;
 IF CHARREMAINDE[256]<32767 THEN BEGIN 
  LIGKERN[NL-1].B2:=(CHARREMAINDE[256]+LKOFFSET)DIV 256;
  LIGKERN[NL-1].B3:=(CHARREMAINDE[256]+LKOFFSET)MOD 256;
 END;
 LF:=6+LH+(EC-BC+1)+MEMORY[1]+MEMORY[2]+MEMORY[3]+MEMORY[4]+NL+LKOFFSET+NK+NE+NP;
 ;
 DH:=LF DIV 256; DL:=LF MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=LH DIV 256; DL:=LH MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=BC DIV 256; DL:=BC MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=EC DIV 256; DL:=EC MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=MEMORY[1] DIV 256; DL:=MEMORY[1] MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=MEMORY[2] DIV 256; DL:=MEMORY[2] MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=MEMORY[3] DIV 256; DL:=MEMORY[3] MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=MEMORY[4] DIV 256; DL:=MEMORY[4] MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=(NL+LKOFFSET) DIV 256; DL:=(NL+LKOFFSET) MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=NK DIV 256; DL:=NK MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=NE DIV 256; DL:=NE MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 DH:=NP DIV 256; DL:=NP MOD 256;
 WRITE(TFMFILE,DH);
 WRITE(TFMFILE,DL);
 ;
 IF NOT(CHECKSUMSPEC) THEN BEGIN 
  WRITELN('Entered checksumspec is false condition.');
  CURBYTES.B0:=BC;
  CURBYTES.B1:=EC;
  CURBYTES.B2:=BC;
  CURBYTES.B3:=EC;
  FOR C:=BC TO EC DO 
   IF CHARWD[C]>0 THEN BEGIN 
    TEMPWIDTH:=MEMORY[CHARWD[C]];
    IF DESIGNUNITS<>1048576 THEN 
     TEMPWIDTH:=ROUND((TEMPWIDTH/DESIGNUNITS)*1048576.0);
    TEMPWIDTH:=TEMPWIDTH+(C+4)*4194304;
    CURBYTES.B0:=(CURBYTES.B0+CURBYTES.B0+TEMPWIDTH)MOD 255;
    CURBYTES.B1:=(CURBYTES.B1+CURBYTES.B1+TEMPWIDTH)MOD 253;
    CURBYTES.B2:=(CURBYTES.B2+CURBYTES.B2+TEMPWIDTH)MOD 251;
    CURBYTES.B3:=(CURBYTES.B3+CURBYTES.B3+TEMPWIDTH)MOD 247;
   END;
  HEADERBYTES[0]:=CURBYTES.B0;
  HEADERBYTES[1]:=CURBYTES.B1;
  HEADERBYTES[2]:=CURBYTES.B2;
  HEADERBYTES[3]:=CURBYTES.B3;
 END;
 HEADERBYTES[4]:=DESIGNSIZE DIV 16777216;
 HEADERBYTES[5]:=(DESIGNSIZE DIV 65536)MOD 256;
 HEADERBYTES[6]:=(DESIGNSIZE DIV 256)MOD 256;
 HEADERBYTES[7]:=DESIGNSIZE MOD 256;
 IF NOT SEVENUNSAFE THEN 
  HEADERBYTES[68]:=128;
 FOR J:=0 TO HEADERPTR-1 DO 
  WRITE(TFMFILE,HEADERBYTES[J]);{:133};{135:}
 INDEX[0]:=0;
 FOR C:=BC TO EC DO BEGIN
  WRITE(TFMFILE,INDEX[CHARWD[C]]);
  DL:=(INDEX[CHARHT[C]]*16+INDEX[CHARDP[C]]) MOD 256;
  WRITE(TFMFILE,DL);
  DL:=(INDEX[CHARIC[C]]*4+CHARTAG[C]) MOD 256;
  WRITE(TFMFILE,DL);
  DL:=CHARREMAINDE[C] MOD 256;
  WRITE(TFMFILE,DL);
 END;
 FOR Q:=1 TO 4 DO BEGIN 
  WRITE(TFMFILE,0);
  WRITE(TFMFILE,0);
  WRITE(TFMFILE,0);
  WRITE(TFMFILE,0);
  P:=LINK[Q];
  WHILE P>0 DO BEGIN 
   OUTSCALED(MEMORY[P]);
   P:=LINK[P];
  END;
 END;
 ;
 IF EXTRALOCNEED THEN BEGIN 
  WRITE(TFMFILE,255);
  DL:=BCHAR MOD 256;
  WRITE(TFMFILE,DL);
  WRITE(TFMFILE,0);
  WRITE(TFMFILE,0);
 END ELSE 
  FOR SORTPTR:=1 TO LKOFFSET DO BEGIN 
   T:=LABELTABLE[LABELPTR].RR;
   IF BCHAR<256 THEN BEGIN 
    WRITE(TFMFILE,255);
    DL:=BCHAR MOD 256;
    WRITE(TFMFILE,DL);
   END ELSE BEGIN 
    WRITE(TFMFILE,254);
    WRITE(TFMFILE,0);
   END;
    DL:=((T+LKOFFSET)DIV 256) MOD 256;
    WRITE(TFMFILE,DL);
    DL:=((T+LKOFFSET)MOD 256) MOD 256;
    WRITE(TFMFILE,DL);
   REPEAT 
    LABELPTR:=LABELPTR-1;
   UNTIL LABELTABLE[LABELPTR].RR<T;
  END;
 IF NL>0 THEN 
  FOR LIGPTR:=0 TO NL-1 DO BEGIN 
   WRITE(TFMFILE,LIGKERN[LIGPTR].B0);
   WRITE(TFMFILE,LIGKERN[LIGPTR].B1);
   WRITE(TFMFILE,LIGKERN[LIGPTR].B2);
   WRITE(TFMFILE,LIGKERN[LIGPTR].B3);
  END;
 IF NK>0 THEN 
  FOR KRNPTR:=0 TO NK-1 DO 
   OUTSCALED(KERN[KRNPTR]){:142};
 IF NE>0 THEN 
  FOR C:=0 TO NE-1 DO BEGIN 
   WRITE(TFMFILE,EXTEN[C].B0);
   WRITE(TFMFILE,EXTEN[C].B1);
   WRITE(TFMFILE,EXTEN[C].B2);
   WRITE(TFMFILE,EXTEN[C].B3);
  END;
   ;
 FOR PARPTR:=1 TO NP DO BEGIN 
  IF PARPTR=1 THEN BEGIN 
   IF PARAM[1]<0 THEN BEGIN 
    PARAM[1]:=PARAM[1]+1073741824;
    DL:=((PARAM[1]DIV 16777216)+192) MOD 256;
    WRITE(TFMFILE,DL);
   END ELSE 
    DL:=(PARAM[1]DIV 16777216) MOD 256;
    WRITE(TFMFILE,DL);
    DL:=(PARAM[1]DIV 65536)MOD 256;
    WRITE(TFMFILE,DL);
    DL:=(PARAM[1]DIV 256)MOD 256;
    WRITE(TFMFILE,DL);
    DL:=(PARAM[1]MOD 256);
    WRITE(TFMFILE,DL);
  END ELSE 
   OUTSCALED(PARAM[PARPTR]);
 END;
 { Added following two lines}
 CLOSE(PLFILE);
 CLOSE(TFMFILE);
END.