-- file: TexSymbols2Impl.mesa
-- Pascal-to-Mesa translator output, translated at September 27, 1985 10:21:37 am PDT


DIRECTORY
  PascalBasic,
  PascalWizardFiles,
  TexTypes,
  TexSysdep,
  TexSysdepInline,
  TexInteraction,
  TexMemory,
  TexSymbols,
  TexScan,
  TexOps,
  TexRest;

TexSymbols2Impl: PROGRAM IMPORTS PascalBasic, PascalWizardFiles, TexTypes, TexSysdep, TexSysdepInline, TexInteraction, TexMemory, TexSymbols, TexScan, TexOps, TexRest EXPORTS TexSymbols = PUBLIC
BEGIN OPEN PascalBasic, PascalWizardFiles, TexTypes, TexSysdep, TexSysdepInline, TexInteraction, TexMemory, TexSymbols, TexScan, TexOps, TexRest;
--:165
--173:--
FontInShortDisplay: PascalInteger;
--:173----181:--
DepthThreshold: PascalInteger;


BreadthMax: PascalInteger;
--:181----213:
Nest: LONG POINTER TO ARRAY PascalInteger[0..40] OF ListStateRecord _ PascalStaticZone.NEW[ARRAY PascalInteger[0..40] OF ListStateRecord];

NestPtr: PascalInteger[0..NestSize];


MaxNestStack: PascalInteger[0..NestSize];

CurList: ListStateRecord;


ShownMode: PascalInteger[-201..201];
--:213----246:--
OldSetting: PascalInteger[0..21];
--:246----253:
Eqtb: LONG POINTER TO ARRAY PascalInteger[1..5476] OF MemoryWord _ PascalStaticZone.NEW[ARRAY PascalInteger[1..5476] OF MemoryWord];

XeqLevel: LONG POINTER TO ARRAY PascalInteger[4767..5476] OF Quarterword _ PascalStaticZone.NEW[ARRAY PascalInteger[4767..5476] OF Quarterword];
--:253----256:
Hash: LONG POINTER TO ARRAY PascalInteger[258..3024] OF TwoHalves _ PascalStaticZone.NEW[ARRAY PascalInteger[258..3024] OF TwoHalves];

HashUsed: Halfword;


NoNewControlSequence: PascalBoolean;

CsCount: PascalInteger;
--:256----271:
SaveStack: LONG POINTER TO ARRAY PascalInteger[0..600] OF MemoryWord _ PascalStaticZone.NEW[ARRAY PascalInteger[0..600] OF MemoryWord];

SavePtr: PascalInteger[0..SaveSize];


MaxSaveStack: PascalInteger[0..SaveSize];

CurLevel: Quarterword;

CurGroup: GroupCode;


CurBoundary: PascalInteger[0..SaveSize];
--:271----286:--
MagSet: PascalInteger;


UsePressFormat: PascalBoolean;
--:286----297:--
CurCmd: EightBits;


CurChr: Halfword;

CurCs: Halfword;

CurTok: Halfword;
--:297----301:
InputStack: LONG POINTER TO ARRAY PascalInteger[0..200] OF InStateRecord _ PascalStaticZone.NEW[ARRAY PascalInteger[0..200] OF InStateRecord];


InputPtr: PascalInteger[0..StackSize];

MaxInStack: PascalInteger[0..StackSize];


CurInput: InStateRecord;
--:301----304:--
InOpen: PascalInteger[0..MaxInOpen];

InputFile: LONG POINTER TO ARRAY PascalInteger[1..6] OF AlphaFile _ PascalStaticZone.NEW[ARRAY PascalInteger[1..6] OF AlphaFile];

Line: PascalInteger;

LineStack: LONG POINTER TO ARRAY PascalInteger[1..6] OF PascalInteger _ PascalStaticZone.NEW[ARRAY PascalInteger[1..6] OF PascalInteger];
--:304----305:

ScannerStatus: PascalInteger[0..5];

WarningIndex: Halfword;

DefRef: Halfword;
--:305----308:
ParamStack: LONG POINTER TO ARRAY PascalInteger[0..60] OF Halfword _ PascalStaticZone.NEW[ARRAY PascalInteger[0..60] OF Halfword];

ParamPtr: PascalInteger[0..ParamSize];


MaxParamStack: PascalInteger;
--:308----309:--
AlignState: PascalInteger;
--:309----310:

BasePtr: PascalInteger[0..StackSize];
--:310----333:--
ParLoc: Halfword;

ParToken: Halfword;
--:361----382:
CurMark: LONG POINTER TO ARRAY PascalInteger[0..4] OF Halfword _ PascalStaticZone.NEW[ARRAY PascalInteger[0..4] OF Halfword];
--:382----387:--
LongState: PascalInteger[110..113];
--:387
--388:--Pstack: LONG POINTER TO ARRAY PascalInteger[0..8] OF Halfword _ PascalStaticZone.NEW[ARRAY PascalInteger[0..8] OF Halfword];
--:388----410:--
CurVal: PascalInteger;


CurValLevel: PascalInteger[0..5];
--:410----438:--
Radix: SmallNumber;
--:438----447:

CurOrder: GlueOrd;
--:447----480:--ReadFile: LONG POINTER TO ARRAY PascalInteger[0..15] OF AlphaFile _ PascalStaticZone.NEW[ARRAY PascalInteger[0..15] OF AlphaFile];

ReadOpen: LONG POINTER TO ARRAY PascalInteger[0..16] OF PascalInteger[0..2] _ PascalStaticZone.NEW[ARRAY PascalInteger[0..16] OF PascalInteger[0..2]];
--:480----489:--
CondPtr: Halfword;


IfLimit: PascalInteger[0..4];

CurIf: SmallNumber;
--:489----493:

SkipLine: PascalInteger;
--:493----512:--
CurName: StrNumber;

CurArea: StrNumber;


CurExt: StrNumber;
--:512----513:--
AreaDelimiter: PoolPointer;


ExtDelimiter: PoolPointer;
--306:-- Runaway: PROCEDURE = 
BEGIN P:Halfword;
 IF  INT[ScannerStatus]>1  THEN BEGIN PrintNl[431];
SELECT ScannerStatus FROM 2 =>BEGIN Print[432];P_DefRef; END;
3 =>BEGIN Print[433];P_64997; END;4 =>BEGIN Print[434];P_64996; END;
5 =>BEGIN Print[435];P_DefRef; END; ENDCASE;PrintChar[63];PrintLn[];
ShowTokenList[Mem[P]^.Hh.Rh,0,ErrorLine-10]; END; END;--:306----:119----120:
  ShowContext: PROCEDURE = 
BEGIN  OldSetting:PascalInteger[0..21];
--315:--I:PascalInteger[0..BufSize];J:PascalInteger[0..BufSize];L:PascalInteger[0..HalfErrorLine];M:PascalInteger;
N:PascalInteger[0..ErrorLine];P:PascalInteger;Q:PascalInteger;--:315-- BasePtr_InputPtr;
InputStack^[BasePtr]_CurInput;
{WHILE TRUE DO BEGIN CurInput_InputStack^[BasePtr];--312:
IF(BasePtr=InputPtr)OR (CurInput.StateField#0)OR (CurInput.
IndexField#3)OR (CurInput.LocField#0) THEN BEGIN Tally_0;
OldSetting_Selector;IF CurInput.StateField#0  THEN BEGIN--313:
IF  INT[CurInput.NameField]<=17  THEN IF(CurInput.NameField=0) THEN IF
BasePtr=0  THEN PrintNl[436] ELSE PrintNl[437] ELSE BEGIN PrintNl[438];
IF CurInput.NameField=17  THEN PrintChar[42] ELSE PrintInt[ INT[CurInput.
NameField]-1];PrintChar[62]; END  ELSE BEGIN PrintNl[439];
PrintInt[Line+( INT[CurInput.LocField]-CurInput.StartField)]; END;
PrintChar[32]--:313--;--318:--BEGIN L_Tally;Tally_0;Selector_20;
TrickCount_1000000; END;
IF Buffer^[CurInput.LimitField]=Eqtb^[4815].Int  THEN J_CurInput.
LimitField  ELSE J_CurInput.LimitField+1;
IF  INT[J]>0  THEN FOR i:INT    IN [ INT[CurInput.StartField ].. INT[J-1 ]] DO  I _ i;  IF I=CurInput.
LocField  THEN BEGIN FirstCount_Tally;
TrickCount_Tally+1+ErrorLine-HalfErrorLine;
IF TrickCount<ErrorLine  THEN TrickCount_ErrorLine; END;
Print[Buffer^[I]];--:318-- ENDLOOP; END  ELSE BEGIN--314:
SELECT CurInput.IndexField FROM 0 =>PrintNl[440];1,2 =>PrintNl[441];
3 =>IF CurInput.LocField=0  THEN PrintNl[442] ELSE PrintNl[443];
4 =>PrintNl[444];5 =>BEGIN PrintLn[];PrintCs[CurInput.NameField]; END;
6 =>PrintNl[445];7 =>PrintNl[446];8 =>PrintNl[447];9 =>PrintNl[448];
10 =>PrintNl[449];11 =>PrintNl[450];12 =>PrintNl[451];13 =>PrintNl[452];
14 =>PrintNl[453];15 =>PrintNl[454]; ENDCASE =>PrintNl[63]--:314--;--319:
BEGIN L_Tally;Tally_0;Selector_20;TrickCount_1000000; END;
IF  INT[CurInput.IndexField]<5  THEN ShowTokenList[CurInput.StartField,
CurInput.LocField,100000] ELSE ShowTokenList[Mem[CurInput.
StartField]^.Hh.Rh,CurInput.LocField,100000]--:319--; END;
Selector_OldSetting;--317:
IF TrickCount=1000000  THEN BEGIN FirstCount_Tally;
TrickCount_Tally+1+ErrorLine-HalfErrorLine;
IF TrickCount<ErrorLine  THEN TrickCount_ErrorLine; END;
IF Tally<TrickCount  THEN M_Tally-FirstCount  ELSE M_
TrickCount-FirstCount;IF L+FirstCount<=HalfErrorLine  THEN BEGIN P_0;
N_L+FirstCount; END  ELSE BEGIN Print[149];
P_L+FirstCount-HalfErrorLine+3;N_HalfErrorLine; END;
FOR i:INT    IN [ INT[P ].. INT[FirstCount-1 ]] DO  Q _ i; PrintChar[TrickBuf^[ PascalMODPower2Mask[Q ,63]]] ENDLOOP;
PrintLn[];FOR i:INT    IN [ INT[1 ].. INT[N ]] DO  Q _ i; PrintChar[32] ENDLOOP;
IF M+N<=ErrorLine  THEN P_FirstCount+M  ELSE P_FirstCount+(ErrorLine
-N-3);
FOR i:INT    IN [ INT[FirstCount ].. INT[P-1 ]] DO  Q _ i; PrintChar[TrickBuf^[ PascalMODPower2Mask[Q ,63]]] ENDLOOP;
IF M+N>ErrorLine  THEN Print[149]--:317--; END--:312--;
IF(CurInput.StateField#0) THEN IF( INT[CurInput.NameField]>17)OR (
BasePtr=0) THEN  GOTO Label30;BasePtr_BasePtr-1; END ENDLOOP ;
EXITS Label30 => NULL};CurInput_InputStack^[InputPtr]; END;--:311----323:
 BeginTokenList: PROCEDURE[P: Halfword,T: Quarterword]
 = 
BEGIN BEGIN IF  INT[InputPtr]>MaxInStack  THEN BEGIN MaxInStack_InputPtr
;IF InputPtr=StackSize  THEN Overflow[455,StackSize]; END;
InputStack^[InputPtr]_CurInput;InputPtr_InputPtr+1; END;
CurInput.StateField_0;CurInput.StartField_P;
CurInput.IndexField_T;
IF  INT[T]>=5  THEN BEGIN Mem[P]^.Hh.Lh_Mem[P]^.Hh.Lh+1;
IF T=5  THEN CurInput.LimitField_ParamPtr  ELSE BEGIN CurInput.
LocField_Mem[P]^.Hh.Rh;IF Eqtb^[4797].Int>1  THEN BEGIN BeginDiagnostic[];
PrintNl[210];SELECT T FROM 14 =>PrintEsc[222];15 =>PrintEsc[456];
 ENDCASE =>PrintCmdChr[71,T+3551];Print[418];TokenShow[P];
EndDiagnostic[FALSE]; END; END; END  ELSE CurInput.LocField_P; END;--:323
--324:-- EndTokenList: PROCEDURE
 = 
BEGIN IF  INT[CurInput.IndexField]>=3  THEN BEGIN IF  INT[CurInput.IndexField]<=4
 THEN FlushList[CurInput.StartField] ELSE BEGIN DeleteTokenRef[
CurInput.StartField];
IF CurInput.IndexField=5  THEN WHILE  INT[ParamPtr]>CurInput.LimitField DO
BEGIN ParamPtr_ParamPtr-1;FlushList[ParamStack^[ParamPtr]]; END ENDLOOP ; END;
 END  ELSE IF CurInput.IndexField=1  THEN AlignState_0;
BEGIN InputPtr_InputPtr-1;CurInput_InputStack^[InputPtr]; END;
BEGIN IF Interrupt#0  THEN PauseForInstructions[]; END; END;--:324----325:
  BackInput: PROCEDURE = 
BEGIN P:Halfword;
 WHILE(CurInput.StateField=0)AND (CurInput.LocField=0)DO
EndTokenList[] ENDLOOP ;P_GetAvail[];Mem[P]^.Hh.Lh_CurTok;
IF  INT[CurTok]<768  THEN IF  INT[CurTok]<512  THEN AlignState_AlignState-1  ELSE
AlignState_AlignState+1;
BEGIN IF  INT[InputPtr]>MaxInStack  THEN BEGIN MaxInStack_InputPtr;
IF InputPtr=StackSize  THEN Overflow[455,StackSize]; END;
InputStack^[InputPtr]_CurInput;InputPtr_InputPtr+1; END;
CurInput.StateField_0;CurInput.StartField_P;
CurInput.IndexField_3;CurInput.LocField_P; END;--:325----327:
 BackError: PROCEDURE = 
BEGIN OkToInterrupt_FALSE;BackInput[];
OkToInterrupt_TRUE;Error[]; END; InsError: PROCEDURE
 = 
BEGIN OkToInterrupt_FALSE;BackInput[];CurInput.IndexField_4;
OkToInterrupt_TRUE;Error[]; END;--:327----328:
 

 BeginFileReading: PROCEDURE = 
BEGIN IF InOpen=MaxInOpen  THEN Overflow[457,MaxInOpen];
IF First=BufSize  THEN Overflow[128,BufSize];InOpen_InOpen+1;
BEGIN IF  INT[InputPtr]>MaxInStack  THEN BEGIN MaxInStack_InputPtr;
IF InputPtr=StackSize  THEN Overflow[455,StackSize]; END;
InputStack^[InputPtr]_CurInput;InputPtr_InputPtr+1; END;
CurInput.IndexField_InOpen;LineStack^[CurInput.IndexField]_Line;
CurInput.StartField_First;CurInput.StateField_1;
CurInput.NameField_0; END;--:328----329:-- EndFileReading: PROCEDURE
 = 
BEGIN First_CurInput.StartField;
Line_LineStack^[CurInput.IndexField];
IF  INT[CurInput.NameField]>17  THEN AClose[@InputFile^[CurInput.IndexField
]];BEGIN InputPtr_InputPtr-1;CurInput_InputStack^[InputPtr]; END;
InOpen_InOpen-1; END;--:329----330:-- 

 ClearForErrorPrompt: PROCEDURE = 
BEGIN  WHILE(CurInput.StateField#0)AND (CurInput.NameField=0)AND (
 INT[InputPtr]>0)AND ( INT[CurInput.LocField]>CurInput.LimitField)DO
EndFileReading[] ENDLOOP ;PrintLn[]; END;--:330----336:
 CheckOuterValidity: PROCEDURE = 
BEGIN P:Halfword;Q:Halfword;
 IF ScannerStatus#0  THEN BEGIN DeletionsAllowed_FALSE;--337:
IF CurCs#0  THEN BEGIN IF(CurInput.StateField=0)OR ( INT[CurInput.
NameField]<1)OR ( INT[CurInput.NameField]>17) THEN BEGIN P_GetAvail[];
Mem[P]^.Hh.Lh_ INT[4096]+CurCs;BeginTokenList[P,3]; END;CurCmd_10;
CurChr_32; END--:337--;IF  INT[ScannerStatus]>1  THEN--338:--BEGIN Runaway[];
IF CurCs=0  THEN BEGIN IF Interaction=3  THEN NULL;PrintNl[134];Print[465];
 END  ELSE BEGIN CurCs_0;BEGIN IF Interaction=3  THEN NULL;PrintNl[134];
Print[466]; END; END;Print[467];--339:--P_GetAvail[];
SELECT ScannerStatus FROM 2 =>BEGIN Print[432];Mem[P]^.Hh.Lh_637; END;
3 =>BEGIN Print[473];Mem[P]^.Hh.Lh_ParToken;LongState_112; END;
4 =>BEGIN Print[434];Mem[P]^.Hh.Lh_637;Q_P;P_GetAvail[];Mem[P]^.Hh.Rh_Q;
Mem[P]^.Hh.Lh_6855;AlignState_-1000000; END;5 =>BEGIN Print[435];
Mem[P]^.Hh.Lh_637; END; ENDCASE;BeginTokenList[P,4]--:339--;Print[468];
SprintCs[WarningIndex];BEGIN HelpPtr_4;HelpLine^[3]_469;
HelpLine^[2]_470;HelpLine^[1]_471;HelpLine^[0]_472; END;Error[];
 END--:338-- ELSE BEGIN BEGIN IF Interaction=3  THEN NULL;PrintNl[134];
Print[459]; END;PrintCmdChr[104,CurIf];Print[460];
PrintInt[SkipLine];BEGIN HelpPtr_3;HelpLine^[2]_461;
HelpLine^[1]_462;HelpLine^[0]_463; END;
IF CurCs#0  THEN CurCs_0  ELSE HelpLine^[2]_464;CurTok_6858;
InsError[]; END;DeletionsAllowed_TRUE; END; END;--:336----340:
--:340----341:-- GetNext: PROCEDURE
 = 
BEGIN  K:PascalInteger[0..BufSize];T:Halfword;Cat:PascalInteger[0..15];
 DO {--Label20:--CurCs_0;{IF CurInput.StateField#0  THEN--343:
BEGIN DO {--Label25:--IF  INT[CurInput.LocField]<=CurInput.LimitField  THEN BEGIN
CurChr_Buffer^[CurInput.LocField];
CurInput.LocField_CurInput.LocField+1;
DO {--Label21:--CurCmd_Eqtb^[ INT[4127]+CurChr].Hh.Rh;--344:
SELECT CurInput.StateField+CurCmd FROM--345:--10,26,42,27,43--:345-- => GOTO Label25;
1,17,33 =>--354:
BEGIN {IF  INT[CurInput.LocField]>CurInput.LimitField  THEN CurCs_257  ELSE
BEGIN DO {--Label26:--K_CurInput.LocField;CurChr_Buffer^[K];
Cat_Eqtb^[ INT[4127]+CurChr].Hh.Rh;K_K+1;
IF Cat=11  THEN CurInput.StateField_17  ELSE IF Cat=10  THEN CurInput.
StateField_17  ELSE CurInput.StateField_1;
IF(Cat=11)AND ( INT[K]<=CurInput.LimitField) THEN--356:
BEGIN DO CurChr_Buffer^[K];Cat_Eqtb^[ INT[4127]+CurChr].Hh.Rh;K_K+1;
 IF(Cat#11)OR ( INT[K]>CurInput.LimitField) THEN EXIT; ENDLOOP;--355:
BEGIN IF Buffer^[K]=CurChr  THEN IF Cat=7  THEN IF  INT[K]<CurInput.LimitField
 THEN BEGIN CurChr_Buffer^[K+1];
IF  INT[CurChr]<64  THEN Buffer^[K-1]_ INT[CurChr]+64  ELSE Buffer^[K-1]_ INT[CurChr]-64;
CurInput.LimitField_ INT[CurInput.LimitField]-2;First_First-2;
WHILE  INT[K]<=CurInput.LimitField DO BEGIN Buffer^[K]_Buffer^[K+2];K_K+1;
 END ENDLOOP ; GOTO Label26; END; END--:355--;IF Cat#11  THEN K_K-1;
IF  INT[K]>CurInput.LocField+1  THEN BEGIN CurCs_IdLookup[CurInput.
LocField, INT[K]-CurInput.LocField];CurInput.LocField_K; GOTO Label40; END;
 END--:356-- ELSE--355:
BEGIN IF Buffer^[K]=CurChr  THEN IF Cat=7  THEN IF  INT[K]<CurInput.LimitField
 THEN BEGIN CurChr_Buffer^[K+1];
IF  INT[CurChr]<64  THEN Buffer^[K-1]_ INT[CurChr]+64  ELSE Buffer^[K-1]_ INT[CurChr]-64;
CurInput.LimitField_ INT[CurInput.LimitField]-2;First_First-2;
WHILE  INT[K]<=CurInput.LimitField DO BEGIN Buffer^[K]_Buffer^[K+2];K_K+1;
 END ENDLOOP ; GOTO Label26; END; END--:355--;CurCs_129+Buffer^[CurInput.LocField];
CurInput.LocField_CurInput.LocField+1;EXIT; EXITS Label26 => NULL} ENDLOOP; END;
EXITS Label40 => NULL};CurCmd_Eqtb^[CurCs].Hh.B0;CurChr_Eqtb^[CurCs].Hh.Rh;
IF  INT[CurCmd]>=112  THEN CheckOuterValidity[]; END--:354--;14,30,46 =>--353:
BEGIN CurCs_CurChr+1;CurCmd_Eqtb^[CurCs].Hh.B0;
CurChr_Eqtb^[CurCs].Hh.Rh;CurInput.StateField_1;
IF  INT[CurCmd]>=112  THEN CheckOuterValidity[]; END--:353--;8,24,40 =>--352:
BEGIN IF(CurChr=Buffer^[CurInput.LocField])AND (
 INT[CurInput.LocField]<CurInput.LimitField) THEN BEGIN IF  INT[Buffer^[CurInput.LocField+1]]<64
 THEN CurChr_Buffer^[CurInput.LocField+1]+64  ELSE CurChr_Buffer^
[CurInput.LocField+1]-64;CurInput.LocField_CurInput.LocField+2;
 GOTO Label21; END;CurInput.StateField_1; END--:352--;16,32,48 =>--346:
BEGIN BEGIN IF Interaction=3  THEN NULL;PrintNl[134];Print[474]; END;
BEGIN HelpPtr_2;HelpLine^[1]_475;HelpLine^[0]_476; END;
DeletionsAllowed_FALSE;Error[];DeletionsAllowed_TRUE; GOTO Label20; END--:346
;--347:--11 =>--349:--BEGIN CurInput.StateField_17;CurChr_32; END--:349--;
6 =>--348:--BEGIN CurInput.LocField_CurInput.LimitField+1;CurCmd_10;
CurChr_32; END--:348--;22,15,31,47 =>--350:
BEGIN CurInput.LocField_CurInput.LimitField+1; GOTO Label25; END--:350--;
38 =>--351:--BEGIN CurInput.LocField_CurInput.LimitField+1;
CurCs_ParLoc;CurCmd_Eqtb^[CurCs].Hh.B0;CurChr_Eqtb^[CurCs].Hh.Rh;
IF  INT[CurCmd]>=112  THEN CheckOuterValidity[]; END--:351--;
2 =>AlignState_AlignState+1;18,34 =>BEGIN CurInput.StateField_1;
AlignState_AlignState+1; END;3 =>AlignState_AlignState-1;
19,35 =>BEGIN CurInput.StateField_1;AlignState_AlignState-1; END;
20,21,23,25,28,29,36,37,39,41,44,45 =>CurInput.StateField_1;--:347
 ENDCASE => NULL--:344--;EXIT; EXITS Label21 => NULL} ENDLOOP; END  ELSE BEGIN CurInput.StateField_33;--360:
IF  INT[CurInput.NameField]>17  THEN--362:
BEGIN Line_FileGetPos[@InputFile^[CurInput.IndexField]];
First_CurInput.StartField;
IF  NOT ForceEof  THEN BEGIN IF InputLn[@InputFile^[CurInput.IndexField
],TRUE] THEN FirmUpTheLine [] ELSE ForceEof_TRUE; END;
IF ForceEof  THEN BEGIN PrintChar[41];ForceEof_FALSE;PascalTextBREAK[file: @TermOut];
EndFileReading[];CheckOuterValidity[]; GOTO Label20; END;
IF(Eqtb^[4815].Int<0)OR (Eqtb^[4815].Int>127) THEN CurInput.LimitField_
 INT[CurInput.LimitField]-1  ELSE Buffer^[CurInput.LimitField]_Eqtb^[4815].
Int;First_CurInput.LimitField+1;
CurInput.LocField_CurInput.StartField; END--:362
 ELSE BEGIN IF NOT (CurInput.NameField=0) THEN BEGIN CurCmd_0;
CurChr_0; GOTO Label10; END;IF  INT[InputPtr]>0  THEN BEGIN EndFileReading[];
 GOTO Label20; END;IF  INT[Selector]<18  THEN OpenLogFile[];
IF  INT[Interaction]>1  THEN BEGIN IF CurInput.LimitField=CurInput.
StartField  THEN PrintNl[477];PrintLn[];First_CurInput.StartField;
BEGIN Print[42];TermInput[]; END;CurInput.LimitField_Last;
IF(Eqtb^[4815].Int<0)OR (Eqtb^[4815].Int>127) THEN CurInput.LimitField_
 INT[CurInput.LimitField]-1  ELSE Buffer^[CurInput.LimitField]_Eqtb^[4815].
Int;First_CurInput.LimitField+1;
CurInput.LocField_CurInput.StartField; END  ELSE FatalError[478];
 END--:360--;BEGIN IF Interrupt#0  THEN PauseForInstructions[]; END; GOTO Label25;
 END;EXIT; EXITS Label25 => NULL} ENDLOOP; END--:343-- ELSE--357:
IF CurInput.LocField#0  THEN BEGIN T_Mem[CurInput.LocField]^.Hh.Lh;
CurInput.LocField_Mem[CurInput.LocField]^.Hh.Rh;
IF  INT[T]>=4096  THEN BEGIN CurCs_ INT[T]-4096;CurCmd_Eqtb^[CurCs].Hh.B0;
CurChr_Eqtb^[CurCs].Hh.Rh;
IF  INT[CurCmd]>=112  THEN IF CurCmd=115  THEN--358:
BEGIN CurCs_ INT[Mem[CurInput.LocField]^.Hh.Lh]-4096;
CurInput.LocField_0;CurCmd_Eqtb^[CurCs].Hh.B0;
CurChr_Eqtb^[CurCs].Hh.Rh;IF  INT[CurCmd]>99  THEN BEGIN CurCmd_0;
CurChr_257; END; END--:358-- ELSE CheckOuterValidity[];
 END  ELSE BEGIN CurCmd_ PascalDIVPower2[T ,8];CurChr_ PascalMODPower2Mask[T ,255];
SELECT CurCmd FROM 1 =>AlignState_AlignState+1;
2 =>AlignState_AlignState-1;5 =>--359:
BEGIN BeginTokenList[ParamStack^[ INT[CurInput.LimitField]+CurChr-1],0];
 GOTO Label20; END--:359--; ENDCASE => NULL; END; END  ELSE BEGIN EndTokenList[]; GOTO Label20;
 END--:357--;--342:
IF  INT[CurCmd]<=5  THEN IF  INT[CurCmd]>=4  THEN IF AlignState=0  THEN--789:
BEGIN IF ScannerStatus=4  THEN FatalError[767];
CurCmd_Mem[CurAlign+5]^.Hh.Lh;Mem[CurAlign+5]^.Hh.Lh_CurChr;
IF CurCmd=63  THEN BeginTokenList[64990,2] ELSE BeginTokenList[Mem[
CurAlign+2]^.Int,2];AlignState_1000000; GOTO Label20; END--:789----:342--;EXITS Label10 => NULL};EXIT; EXITS Label20 => NULL} ENDLOOP; END;
--:341----363:--  FirmUpTheLine: PROCEDURE = 
BEGIN K:PascalInteger[0..BufSize];
 CurInput.LimitField_Last;
IF Eqtb^[4795].Int>0  THEN IF  INT[Interaction]>1  THEN BEGIN PrintLn[];
IF  INT[CurInput.StartField]<CurInput.LimitField  THEN FOR i:INT    IN [ INT[CurInput.
StartField ].. INT[ INT[CurInput.LimitField]-1 ]] DO  K _ i; Print[Buffer^[K]] ENDLOOP;
First_CurInput.LimitField;BEGIN Print[479];TermInput[]; END;
IF  INT[Last]>First  THEN BEGIN FOR i:INT    IN [ INT[First ].. INT[Last-1 ]] DO  K _ i; Buffer^[ INT[K]+CurInput.
StartField-First]_Buffer^[K] ENDLOOP;
CurInput.LimitField_ INT[CurInput.StartField]+Last-First; END; END; END;
 InsertRelax: PROCEDURE = 
BEGIN CurTok_ INT[4096]+CurCs;BackInput[];
CurTok_6861;BackInput[];CurInput.IndexField_4; END;--:379
  GetXToken: PROCEDURE = 
BEGIN  DO {--Label20:--GetNext[];
{IF  INT[CurCmd]<=99  THEN  GOTO Label30;
IF  INT[CurCmd]>=110  THEN IF  INT[CurCmd]<114  THEN MacroCall [] ELSE BEGIN CurCs_
2764;CurCmd_9; GOTO Label30; END  ELSE Expand[]; GOTO Label20;
EXITS Label30 => NULL};IF CurCs=0  THEN CurTok_ INT[(CurCmd*256)]+CurChr  ELSE CurTok_
 INT[4096]+CurCs;EXIT; EXITS Label20 => NULL} ENDLOOP; END;--:380----381:-- XToken: PROCEDURE
 = 
BEGIN WHILE  INT[CurCmd]>99 DO BEGIN Expand[];GetNext[]; END ENDLOOP ;
IF CurCs=0  THEN CurTok_ INT[(CurCmd*256)]+CurChr  ELSE CurTok_
 INT[4096]+CurCs; END;--:381----403:--
END.