(* PASS1.MOD — DRAFT v1, assembled 2026-10-03, NOT verified.
   Reconstructed from Reversing-Turbo-Modula2-main/MCode_disassembly/pass1.txt
   (2975 lines) by three parallel passes (groups 1 @0001-02e6, 2 @02e6-07a8,
   3 @07a8-end). Does NOT yet recompile to the original MCD; verification
   via unassemble.c diff is still required (see src/compiler/README.md).

   Frame rule applied throughout (proven, see STATEMEN.MOD header):
   "param1" = LAST pushed word; call sites from pushes stay source-order.
   Signatures are source-order with body roles noted; disagreements flagged.

   OPEN DISPUTES (MCD diff decides):
   - D1/D2: proc15 (@0411, 0-param, type-symbol dispatch in every TYPE
     position) reads as ParseType, while proc19 (@02e6, 3-param, ident-list
     loop) reads as ParseFormalParams — i.e. possibly SWAPPED vs the map
     used here (proc15=ParseFormalParams, proc19=ParseType). Group 2's
     detailed enum/pointer/record/array reading of @02e6-0410 is kept.
   - D3/D4: proc17 body builds ARRAY descriptors, proc18 parses [lo..hi]
     SUBRANGEs — kept as ParseConstDecl/ParseVarDecl (map names) pending
     group-3 cross-check of where real const/var decls live (cf. proc23?).
   - proc9: map said ~WriteSymFile, body parses procedure bodies with NO
     file calls — kept as ParseProcBody. The real .SYM writer is then
     probably proc32 @0db2 (file-output path), which was NOT decompiled
     (missing mini-pass — next workstream).
   - proc36 @0e93 slot holds the COMPILE link stub's keyword-table search
     (patched over); original forward-resolution sweep LOST (cf.
     SymTab.CheckForwards which may be the same sweep).
   - No bytes exist for proc10/11/26/27/29/30 (FORWARD stubs),
     PASS1 @1027 / 4NAZBA @105b (FORWARD stubs).
   - ConstToCard/ConstToInt call shapes (type-first: ConstToCard(CardType,44))
     vs EXPRESS.DEF order (errPos, c) disagree — signature-audit item.
   - PASS1 globals: word2 emitBase (ADDRESS buffer; group 1's tempBase),
     word3 emitTop (index; group 1's tempTop), word4 nestDepth.
     Group-1 SymTab.word4/word5 pun uses kept verbatim + FIXME.

   Words(X)^[N] = numeric-word pun (MCode untyped). BITSET(numeric) sets,
   CARDINAL<->ADDRESS punning, and `IN`-tests on CARDINAL curSymbol kept
   verbatim (casts TBD in verification). GOTO kept as faithful rendering. *)

IMPLEMENTATION MODULE Pass1;
IMPORT Compiler, Scanner, Errors, CodeGen, Express, Statemen, SymTab, Files,
       Texts, Loader, ComLine;
FROM SYSTEM IMPORT ADDRESS, ADR, MOVE, WORD;
FROM STORAGE IMPORT ALLOCATE;

TYPE Words = POINTER TO ARRAY [0..4095] OF WORD;

VAR
  emitBase: ADDRESS;   (* word2: output/emit buffer base *)
  emitTop: CARDINAL;   (* word3: emit buffer top *)
  nestDepth: CARDINAL; (* word4: DEC'd on PROCDE/MODULD exit *)

(* ---- group-1/3 shared FORWARDs (defined below) ---- *)
PROCEDURE PushTempMark(): CARDINAL; FORWARD;
PROCEDURE PopTempMark(first, second: WORD); FORWARD;
PROCEDURE AllocSymEntry(size: WORD); FORWARD;
PROCEDURE LinkSymEntry(entry: ADDRESS); FORWARD;
PROCEDURE InsertSetConst(first: ADDRESS; limit: CARDINAL); FORWARD;
PROCEDURE CondInsert(flag: WORD; slot: ADDRESS; a, b: WORD): CARDINAL; FORWARD;
PROCEDURE InsertEntry(setD, counter, slotA, slotB: ADDRESS): CARDINAL; FORWARD;
PROCEDURE OpenScopeEmit(node: ADDRESS); FORWARD;
PROCEDURE TypeSizeRec(node, link, acc, aux, size: WORD); FORWARD;
PROCEDURE GetIdent(): ADDRESS; FORWARD;
PROCEDURE ParseImportItem(first: CARDINAL): ADDRESS; FORWARD;
PROCEDURE ParseConstDecl(): ADDRESS; FORWARD;
PROCEDURE ParseVarDecl(first: WORD); FORWARD;
PROCEDURE ParseType(owner: ADDRESS; VAR typ: ADDRESS; limit: CARDINAL): ADDRESS; FORWARD;
PROCEDURE ParseFormalParams(): ADDRESS; FORWARD;
PROCEDURE ParseValParam(): ADDRESS; FORWARD;
PROCEDURE ParseVarParam; FORWARD;
PROCEDURE ParseFieldList; FORWARD;
PROCEDURE EvalConstExpr; FORWARD;
PROCEDURE CheckConformant(): ADDRESS; FORWARD;
PROCEDURE ParseRecordType(rec: ADDRESS; VAR size: CARDINAL; tag: CARDINAL); FORWARD;
PROCEDURE CloseScopeFixup; FORWARD;
PROCEDURE ParseProcedureDecl; FORWARD;
PROCEDURE ParseModuleHead; FORWARD;
PROCEDURE ParseExportList; FORWARD;
PROCEDURE ParseOneDecl; FORWARD;
PROCEDURE ParseDeclarations(follow: BITSET): BOOLEAN; FORWARD;
PROCEDURE ParseImportFrom; FORWARD;
PROCEDURE ParseModuleBlock(modNode: ADDRESS); FORWARD;
PROCEDURE ParseProcBody(procNode: ADDRESS); FORWARD;
PROCEDURE ParseMainModule(): BOOLEAN; FORWARD;
PROCEDURE WriteMcdHeader; FORWARD;
PROCEDURE EmitConstVal(buf: ADDRESS; count: CARDINAL); FORWARD;
PROCEDURE EmitTypeDesc; FORWARD;
(* stubs: no bytes anywhere *)
PROCEDURE EmitModuleProlog(node: ADDRESS); FORWARD; (* proc10 *)
PROCEDURE ParseDeclSync; FORWARD; (* proc11 *)
PROCEDURE ParseConstOrTypeArm; FORWARD; (* proc26 *)
PROCEDURE ParseModuleArm; FORWARD; (* proc27 *)
PROCEDURE TryParseDecl(tag: CARDINAL): BOOLEAN; FORWARD; (* proc29 *)
PROCEDURE ParseImportScope; FORWARD; (* proc30 *)
PROCEDURE CheckForwardResolved; FORWARD; (* proc36: body patched away *)
PROCEDURE Pass1Main; FORWARD; (* @1027: no bytes *)
PROCEDURE InitPass1; FORWARD; (* 4NAZBA @105b: no bytes *)
(* SCANNER.proc24 discovery (group 1): 2-param length-prefix function *)
PROCEDURE CappedStrLen(s: ADDRESS; maxLen: CARDINAL): CARDINAL; FORWARD;

(* PASS1 group 1 @0001..02e5 *)

(* SCANNER.proc24 discovery: 2-param FUNCTION (nameAddr, 128) -> length
   prefix for EmitWord/Emit1. Identity TBD. *)
PROCEDURE CappedStrLen(s: ADDRESS; maxLen: CARDINAL): CARDINAL; FORWARD;

(* proc4 @0001 ~PushTempMark. 0 params, function. *)
PROCEDURE PushTempMark(): CARDINAL; (*{0001}*)
BEGIN
  Express.CentralError(SymTab.stringPoolPtr < emitTop - 1, 82); (*{0003-000a} FIXME: group read SymTab.word4=symFile:FILE — pun suspicious; role TBD *)
  INC(SymTab.stringPoolPtr); (*{000c-000f} FIXME *)
  RETURN SymTab.stringPoolPtr; (*{0011-0013} FIXME *)
END PushTempMark;

(* proc5 @0016 ~PopTempMark. 2 params: body param1 = source formal2. *)
PROCEDURE PopTempMark(first, second: WORD); (*{0016} FIXME order: frame rule says formal1=last-pushed *)
BEGIN
  Express.CentralError(SymTab.stringPoolPtr < emitTop - 2, 82); (*{0018-0020} FIXME same as above *)
  DEC(emitTop); (*{0022-0024} FIXME: group used tempTop *)
  Words(emitBase)^[emitTop] := second; (*{0025-0028} *)
  DEC(emitTop); (*{0029-002b}*)
  Words(emitBase)^[emitTop] := first; (*{002c-002f}*)
END PopTempMark;

(* proc6 @0032 ~AllocSymEntry. 1 param. *)
PROCEDURE AllocSymEntry(size: WORD); (*{0032}*)
BEGIN
  IF Express.spillFlag = 0 THEN (*{0034-0037} *)
    WHILE (emitTop <= 254) AND (Words(emitBase)^[emitTop] >= size) DO (*{0039-0044}*)
      emitTop := emitTop + 2; (*{0046-0049} first-fit scan, 2-word slots *)
    END;
  END;
  SymTab.moduleCount := size; (*{004c-004d} FIXME: group wrote word5=stringPoolPtr; moduleCount=word3? BOTH punned — TBD *)
END AllocSymEntry;

(* proc7 @0051 ~LinkSymEntry. 1 param. *)
PROCEDURE LinkSymEntry(entry: ADDRESS); (*{0051}*)
BEGIN
  FILL(entry, 508, 0); (*{0053-0058} per Extended.Fill *)
  WHILE emitTop <= 254 DO (*{005a-005e}*)
    Words(emitBase)^[(Words(emitBase)^[emitTop] DIV 2) - 2] := Words(emitBase)^[emitTop + 1]; (*{0060-006c} dead push harmless *)
    emitTop := emitTop + 2; (*{006d-0070}*)
  END;
END LinkSymEntry;

(* proc1 @007c ~InsertSetConst. 2 params: first = body param2. *)
PROCEDURE InsertSetConst(first: ADDRESS; limit: CARDINAL); (*{007c} FIXME roles *)
VAR
  setBitsA: ARRAY [0..3] OF WORD;
  elemBufA: ARRAY [0..63] OF WORD;
  setBits: ADDRESS;
  elemBuf: ADDRESS;
  cursor: ADDRESS;
  count: CARDINAL;
  allocSize: CARDINAL;
  heapStr: ADDRESS;
  tmp: WORD;
BEGIN
  setBits := ADDRESS(ADR(setBitsA)); (*{007e-0080} *)
  elemBuf := ADDRESS(ADR(elemBufA)); (*{0081-0084} *)
  cursor := Words(first)^[6]; (*{0085-0087} FIXME field roles TBD *)
  IF (cursor # NIL)
     AND (Compiler.scopeSpare3 = NIL)
     AND NOT SymTab.BuildBitsetConst(Words(first)^[1]) THEN (* FIXME: VAR ARRAY arg pun *)
    count := 0; (*{0097-0098}*)
    LOOP (*{0099}*)
      tmp := Words(cursor)^[2]; (*{0099-009b} element value *)
      IF tmp >= limit THEN RETURN END; (*{009b-009f} *)
      IF 4 IN BITSET(Words(cursor)^[3]) THEN (*{00a0-00a4} *)
        Words(setBits)^[count DIV 16] :=
          CARDINAL(BITSET(Words(setBits)^[count DIV 16]) + BITSET{count MOD 16}); (*{00a6-00b4} *)
      END;
      Words(elemBuf)^[count] := tmp; (*{00b5-00b9} *)
      INC(count); (*{00ba-00bc}*)
      cursor := Words(cursor)^[0]; (*{00bd-00bf} next link *)
      IF cursor = NIL THEN EXIT END; (*{00c0-00c2}*)
    END;
    Scanner.CheckStackMark(ADDRESS(limit)); (*{00c4-00c5} FIXME: limit punned as mark *)
    allocSize := ((count + 15) DIV 16) * 2; (*{00c7-00cc} *)
    Scanner.Allocate(heapStr, allocSize + count * 2 + 2); (*{00cf-00d8} *)
    Words(heapStr)^[0] := count; (*{00da-00dc}*)
    MOVE(ADDRESS(Words(heapStr)^[1]), setBits, allocSize); (*{00dd-00e3} *)
    MOVE(ADDRESS(Words(Words(heapStr)^[1] + allocSize)^[0]), elemBuf, count * 2); (*{00e4-00ed} *)
    Words(first)^[6] := heapStr; (*{00ef-00f1} *)
  ELSE
    Words(first)^[6] := heapStr; (*{00ef-00f1} FIXME: guard-false store quirk TBD *)
  END;
END InsertSetConst;

(* proc2 @00f4 ~CondInsert. 4 params: (flag,slot,a,b) = body (param4..1). *)
PROCEDURE CondInsert(flag: WORD; slot: ADDRESS; a, b: WORD): CARDINAL; (*{00f4}*)
BEGIN
  IF flag # 0 THEN (*{00f6-00f8}*)
    Words(slot)^[0] := flag; (*{00fa-00fc}*)
    IF Words(flag)^[0] - 1 < 64 THEN (*{00fd-0107} flag punned as address *)
      Words(slot)^[0] := 1;
    END;
    RETURN InsertEntry(flag, slot, a, b); (*{0108-010d} *)
  END;
  RETURN 0; (*{010f-0110}*)
END CondInsert;

(* proc3 @0113 ~InsertEntry. 4 params. *)
PROCEDURE InsertEntry(setD, counter, slotA, slotB: ADDRESS): CARDINAL; (*{0113}*)
VAR
  idx: CARDINAL;
  base: ADDRESS;
BEGIN
  IF Words(counter)^[0] # 0 THEN (*{0115-0118}*)
    IF Words(setD)^[0] - 1 < 64 THEN (*{011a-0120} small-set path *)
      idx := Words(counter)^[0] - 1; (*{0122-0125}*)
      base := setD; (*{0126-0127}*)
      Words(slotA)^[0] := Words(base)^[1 + (Words(base)^[0] + 15) DIV 16 + idx]; (*{0128-0138} *)
      Words(slotB)^[0] := ORD((idx MOD 16) IN BITSET(Words(base)^[1 + idx DIV 16])); (*{0139-0148} *)
      Words(counter)^[0] := idx + 2; (*{0149-014d} *)
      IF Words(base)^[0] - 1 = idx THEN
        Words(counter)^[0] := 0; (*{0155-0157} full *)
      END;
    ELSE (*{015a} large path *)
      Words(slotA)^[0] := Words(Words(counter)^[0])^[2]; (*{015a-015e} *)
      Words(slotB)^[0] := ORD(4 IN BITSET(Words(Words(counter)^[0])^[3])); (*{015f-0165} *)
      Words(counter)^[0] := Words(Words(counter)^[0])^[0]; (*{0166-016a} *)
    END;
    RETURN 1; (*{016b-016c}*)
  END;
  RETURN 0; (*{016e-016f}*)
END InsertEntry;

(* proc8 @017b ~OpenScopeEmit. 1 param. *)
PROCEDURE OpenScopeEmit(node: ADDRESS); (*{017b}*)
VAR mark: CARDINAL;
BEGIN
  mark := PushTempMark(); (*{017d-017e} *)
  IF Compiler.rangeCheckEnabled THEN (*{017f-0182} *)
    CodeGen.EmitExtCall3(2, mark, 0); (*{0183-0186} *)
    CodeGen.EmitWord(CappedStrLen(Words(node)^[5], 128)); (*{0189-0190} *)
    Words(node)^[6] := mark; (*{0192-0194} *)
    Words(emitBase)^[mark] := CodeGen.nextEmitPos; (*{0195-0199} *)
    CodeGen.EmitString(Words(node)^[5]); (*{019a-019c} NUL-terminated *)
  END;
END OpenScopeEmit;

(* proc12 @01a1 ~TypeSizeRec. 5 params, RECURSIVE. *)
PROCEDURE TypeSizeRec(node, link, acc, aux, size: WORD); (*{01a1} FIXME roles/order *)
VAR skipAdd: BOOLEAN;
BEGIN
  IF Words(node)^[0] # link THEN (*{01a3-01a7} follow indirection *)
    TypeSizeRec(Words(node)^[0], link, acc, aux, size); (*{01a9-01b0} *)
  END;
  IF Words(node)^[4] = 4 THEN (*{01b2-01b6} record-ish kind *)
    Words(node)^[2] := aux; (*{01b8-01ba}*)
    IF NOT (8 IN BITSET(Words(node)^[3])) THEN RETURN END; (*{01bb-01c0} *)
    skipAdd := (Express.spillFlag # 0) AND (Words(node)^[3] = 0); (*{01c2-01cb} *)
    IF skipAdd THEN (*{01cc-01d4} *)
      Words(acc)^[0] := Words(acc)^[0] - size;
    END;
    Words(node)^[5] := Words(acc)^[0]; (*{01d5-01d8} publish offset *)
    IF (Express.spillFlag = 0) AND (Words(aux)^[4] > 9)
       AND (Words(node)^[3] = 0) THEN (*{01d9-01e8} *)
      PopTempMark(Words(acc)^[0], (Words(aux)^[3] + 1) DIV 2 * 2); (*{01ea-01f3} *)
    END;
    IF NOT skipAdd THEN (*{01f4-01fd} *)
      Words(acc)^[0] := Words(acc)^[0] + size;
    END;
  END;
END TypeSizeRec;

(* proc13 @0201 ~GetIdent. 0 params, function. *)
PROCEDURE GetIdent(): ADDRESS; (*{0201} FIXME: name says ident, returns a TYPE *)
VAR typ: ADDRESS;
BEGIN
  Scanner.PushWithScope; (*{0203} *)
  Scanner.ExpectIdentKind(3); (*{0205-0206} *)
  typ := Scanner.literalType; (*{0208-020a} pre-GetSym *)
  Scanner.GetSym; (*{020b}*)
  RETURN typ; (*{020d-020e}*)
END GetIdent;

(* proc16 @0211 ~ParseImportItem. 1 param function. *)
PROCEDURE ParseImportItem(first: CARDINAL): ADDRESS; (*{0211} FIXME role of flag *)
VAR
  item: ADDRESS;
  node: ADDRESS;
BEGIN
  Scanner.ExpectSymbol(42); (*{0213-0216} FROM *)
  node := Scanner.NewSizedNode(5); (*{0217-021a}*)
  Words(node)^[3] := 2; (*{021b-021e}*)
  IF (first # 0) AND (Scanner.identKind = 0)
     AND (Scanner.scopeCursor = NIL) THEN (*{021e-0229} *)
    item := Scanner.DeclareIdentifier(0); (*{022b-022f} plain item *)
    Words(item)^[2] := node; (*{0230-0232} *)
  ELSE
    Words(node)^[2] := ParseType(); (*{0235-0239} FIXME: 0-arg vs 3-param def *)
  END;
  RETURN node; (*{023a-023b}*)
END ParseImportItem;

(* proc17 @023e ~ParseConstDecl. 0 params function.
   DISPUTE D3: body builds an ARRAY descriptor — rename to ParseArrayType
   pending group-3 cross-check. Map name kept. *)
PROCEDURE ParseConstDecl(): ADDRESS; (*{023e}*)
VAR
  arrDesc: ADDRESS;
  idxDesc: ADDRESS;
  elemDesc: ADDRESS;
BEGIN
  arrDesc := Scanner.NewSizedNode(11); (*{0240-0243}*)
  idxDesc := ParseType(); (*{0244-0248} FIXME arity *)
  Words(Express.curDesc.raw[0])^[0] := idxDesc; (*{024c-0250} *)
  Express.MatchOpClass(BITSET{3}, 47); (*{0251-0253} index ordinal *)
  IF Scanner.AcceptSymbol(1) THEN (*{0255-0256} *)
    elemDesc := ParseConstDecl(); (*{025a-025d} recurse *)
  ELSE
    Scanner.ExpectSymbol(41); (*{0260-0262} OF *)
    elemDesc := ParseType(); (*{0264-0268} FIXME arity *)
  END;
  Words(arrDesc)^[5] := elemDesc; (*{0269-026b} *)
  Words(arrDesc)^[3] := (Words(idxDesc)^[6] - Words(idxDesc)^[5] + 1) * Words(elemDesc)^[3]; (*{026c-0276} *)
  RETURN arrDesc; (*{0277-0278}*)
END ParseConstDecl;

(* proc18 @027b ~ParseVarDecl. 1 param function.
   DISPUTE D4: body parses [lo..hi] SUBRANGE — rename to ParseSubrangeType
   pending. Map name kept. *)
PROCEDURE ParseVarDecl(first: WORD); (*{027b} FIXME punned ADDRESS/value *)
VAR desc: ADDRESS;
BEGIN
  desc := Scanner.NewSizedNode(1); (*{027d-0280} subrange desc *)
  Express.GetConstVal; (*{0281} lower bound *)
  IF first = 0 THEN (*{0283-0285} anonymous *)
    Words(desc)^[2] := Words(Express.curDesc.raw[0])^[0]; (*{0287-028c} *)
  ELSE
    IF Words(first)^[4] = 1 THEN first := Words(first)^[2] END; (*{028e-0296} *)
    Express.ConstToCard(first, 0); (*{0297-0299} FIXME: (c,errPos) vs DEF order *)
    Words(desc)^[2] := first; (*{029b-029d} lo *)
  END;
  Express.MatchOpClass(BITSET{5}, 0); (*{029e-02a0} FIXME errCode 0 *)
  Words(desc)^[5] := Words(Express.curDesc.raw[0])^[2]; (*{02a2-02a6} lo value *)
  Scanner.ExpectSymbol(4); (*{02a7-02a8} `..` *)
  Express.GetConstVal; (*{02aa} upper bound *)
  Express.ConstToCard(Words(desc)^[2], 0); (*{02ac-02af} FIXME order *)
  Words(desc)^[6] := Words(Express.curDesc.raw[0])^[2]; (*{02b1-02b5} hi value *)
  IF Words(desc)^[2] = Compiler.IntType THEN
    Express.CentralError(Words(desc)^[6] >= Words(desc)^[5], 46); (*{02bd-02c4} *)
  ELSE
    Express.CentralError(Words(desc)^[6] >= Words(desc)^[5], 46); (*{02c8-02cf} *)
  END;
  Scanner.ExpectSymbol(6); (*{02d1-02d2} `]` *)
  Words(desc)^[3] := ORD((Words(desc)^[5] > 32767) OR (Words(desc)^[6] > 255)) + 1; (*{02d4-02e2} *)
  RETURN desc; (*{02e2-02e3}*)
END ParseVarDecl;
(* PASS1 group 2 @02e6-0783.
   DISPUTE D1/D2 (group 1): proc15 reads as ParseType, proc19 as
   ParseFormalParams. Group 2's detailed readings kept with map names;
   MCD diff decides. See header. *)

(* proc19 @02e6 — ~ParseType (map name; see D2). 3 formals. *)
PROCEDURE ParseType(owner: ADDRESS; VAR typ: ADDRESS; limit: CARDINAL): ADDRESS;
VAR t, u: ADDRESS;
    lo, hi: CARDINAL;
    loA, hiA: ADDRESS;
    n, cnt, elemT: CARDINAL;
    enumBase: ADDRESS;
    tmp: CARDINAL;
BEGIN
  WHILE Scanner.curSymbol IN BITSET{9984H} DO (*{02eb} FIXME: set TBD *)
    IF Scanner.AcceptSymbol(40) THEN (*{02f5} *)
      IF Scanner.AcceptSymbol(2) THEN (*{02fb} *)
        elemT := CARDINAL(GetIdent()); (*{0300} FIXME pun *)
      ELSE
        Scanner.DeclareIdentifier(4); (*{0308} *)
        typ := owner; (*{030d-0327} FIXME: stack shuffles idealized *)
        elemT := CARDINAL(GetIdent());
      END;
      Express.MatchOpClass(BITSET{7}, 40); (*{032c} *)
      Scanner.ExpectSymbol(41); (*{0331} *)
      enumBase := typ; (*{0335} *)
      cnt := 0; (*{0338} *)
      WHILE NOT (Scanner.curSymbol IN BITSET{9472H}) DO (*{033a-03b1} enum loop *)
        tmp := cnt; t := elemT; (*{0343-0344}*)
        Express.GetTypeDesc(loA, hiA, NIL); (*{0346} FIXME: (dest,mode,src) roles *)
        lo := CARDINAL(loA); hi := CARDINAL(hiA); (*{034c-034f} FIXME pun *)
        IF lo <= hi THEN (*{0350} *)
          t := cnt;
          REPEAT
            t := Scanner.NewSizedNode(12); (*{0357} *)
            Words(t)^[6] := u; Words(t)^[2] := elemT; (*{035b-0366} FIXME pun *)
            Words(t)^[3] := enumBase; Words(t)^[7] := lo; (*{0361-0366}*)
            IF u # NIL THEN (*{0367} *)
              IF u # lo THEN Express.CentralError(TRUE, 47); END; (*{036b-0371} FIXME cond *)
              u := Words(u)^[6]; (*{0373-0375} FIXME pun *)
            END;
            INC(lo); (*{0378-037a} *)
          UNTIL lo > hi;
        END;
        IF NOT (Scanner.TestSymbolInSet(6) AND Scanner.AcceptSymbol(1)) THEN EXIT END; (*{037c-0384} FIXME: TestSymbolInSet is VOID assert *)
        Scanner.GetSym; (*{0386} *)
        t := cnt;
        typ := ParseType(owner, t, limit); (*{0388-0390} recursive FIXME arity *)
        u := typ;
        IF Words(t)^[3] > limit THEN limit := Words(t)^[3]; END; (*{03a6-03b0} *)
      END;
      WHILE NOT (Scanner.TestSymbolInSet(8) AND Scanner.AcceptSymbol(1)) DO END; (*{03b6-03ba} FIXME shape *)
      IF Scanner.AcceptSymbol(10) THEN (*{03bc-03bf} *)
        tmp := CARDINAL(ParseType(owner, tmp, limit)); (*{03c1-03c7} FIXME pun *)
        IF CARDINAL(enumBase) > limit THEN limit := CARDINAL(enumBase); END; (*{03c9-03d1} FIXME *)
      END;
      Scanner.ExpectSymbol(13); (*{03d2} *)
      typ := ADDRESS(cnt); (*{03d5-03d7} FIXME pun *)
    ELSE
      Scanner.DeclareIdentifier(4); (*{03da} *)
      tmp := Scanner.curNode; (*{03de} FIXME: ADDRESS := RecordPtr pun *)
      WHILE NOT (Scanner.TestSymbolInSet(6) AND Scanner.AcceptSymbol(1)) DO END; (*{03e2-03e9} FIXME shape *)
      Scanner.GetSym; (*{03eb} *)
      elemT := CARDINAL(ParseFormalParams()); (*{03ed} FIXME pun *)
      typ := owner; (*{03f2-0406} FIXME: TypeSizeRec + word9 wiring *)
      tmp := TypeSizeRec(owner, elemT, elemT, elemT, elemT); (*{03f7-0400} FIXME: 5-arg shape TBD *)
    END;
    IF NOT Scanner.AcceptSymbol(9) THEN EXIT END; (*{0407-040b} *)
  END;
  RETURN typ; (*{040e} *)
END ParseType;

(* proc15 @0411 — ~ParseFormalParams (map name; see D1). 0-param function. *)
PROCEDURE ParseFormalParams(): ADDRESS;
VAR head, n, kind: CARDINAL;
    tail, cur: ADDRESS;
BEGIN
  IF Scanner.AcceptSymbol(43) THEN (*{0413} *)
    head := CARDINAL(Scanner.NewSizedNode(0)); n := 0; (*{0419-041e} FIXME pun *)
    Scanner.DeclareIdentifier(1); kind := CARDINAL(Scanner.curNode); (*{041f-0423} FIXME *)
    INC(n);
    WHILE Scanner.TestSymbolInSet(34) AND Scanner.AcceptSymbol(1) DO (*{0432-0439} FIXME shape *)
      Scanner.DeclareIdentifier(1);
    END;
    Scanner.GetSym; (*{043c} *)
  ELSIF Scanner.AcceptSymbol(44) THEN (*{044c-044e} *)
    head := CARDINAL(ParseVarDecl(0)); (* nested proc18 FIXME *)
  ELSIF Scanner.AcceptSymbol(50) THEN (*{0458-045b} *)
    Scanner.ExpectSymbol(41); (*{045e} *)
    head := CARDINAL(Scanner.NewSizedNode(4)); (*{0462} FIXME *)
    Words(ADDRESS(head))^[3] := 2; (*{0466-0468} FIXME *)
    tail := ParseFormalParams(); (*{0469} FIXME: recursion? *)
    Words(ADDRESS(head))^[2] := tail; (*{046d-046f} FIXME *)
    Express.MatchOpClass(BITSET{3}, 50); (*{0470-0477} *)
    IF Words(tail)^[6] > 15 THEN Express.CentralError(TRUE, 41); END; (*{0479} FIXME cond *)
  ELSIF Scanner.AcceptSymbol(48) THEN (*{0483-0486} *)
    head := CARDINAL(ParseImportItem(0)); (*{0489} FIXME *)
  ELSIF Scanner.AcceptSymbol(21) THEN (*{0490-0493} *)
    head := CARDINAL(Scanner.NewSizedNode(9)); (*{0496} FIXME *)
    Words(ADDRESS(head))^[3] := 4; (*{049a-049c} FIXME *)
    ParseRecordType(ADDRESS(head), sizeTmp, 1); (*{049d-04a5} FIXME: VAR/size shape TBD *)
  ELSIF Scanner.AcceptSymbol(47) THEN (*{04a9-04ac} *)
    head := CARDINAL(ParseConstDecl()); (* nested proc17 *)
  ELSIF Scanner.AcceptSymbol(49) THEN (*{04b4-04b7} *)
    head := CARDINAL(Scanner.NewSizedNode(10)); (*{04ba} FIXME *)
    Scanner.OpenScope(SymTab.currentScope, NIL); (*{04bd-04bf} FIXME args *)
    ParseType(ADDRESS(head), typeTmp, typeLim); (*{04c1-04cd} FIXME args *)
    Scanner.ExpectSymbol(13); (*{04cf} *)
    SymTab.currentScope := Scanner.curNode; (*{04d2-04d5} FIXME: T1 := RecordPtr pun *)
    IF Words(ADDRESS(head))^[3] < 2 THEN Words(ADDRESS(head))^[3] := 2; END; (*{04d7-04df} *)
  ELSE
    head := CARDINAL(GetIdent()); (*{04e2} FIXME pun *)
    IF Scanner.AcceptSymbol(44) THEN head := CARDINAL(ParseVarDecl(0)); END; (*{04e6-04ef} *)
  END;
  RETURN ADDRESS(head); (*{04f0} FIXME pun *)
END ParseFormalParams;

(* proc20 @04f4 — ~ParseValParam. 0 formals, returns type desc. *)
PROCEDURE ParseValParam(): ADDRESS;
VAR t: ADDRESS;
BEGIN
  IF Scanner.AcceptSymbol(48) THEN (*{04f6} *)
    t := ParseImportItem(0); (*{04fc-04fe} FIXME arg *)
  ELSE
    t := ParseFormalParams(); (*{0503-0504} *)
  END;
  RETURN t; (*{0507} *)
END ParseValParam;

(* proc21 @050b — ~ParseVarParam. 0 formals, no result. *)
PROCEDURE ParseVarParam;
VAR t: ADDRESS;
BEGIN
  WHILE Scanner.curSymbol = 0 DO (*{050d-0543} *)
    t := Scanner.MakeIdentifierNode(1); (*{0512-0514} FIXME: ADDRESS := ADDRESS ok *)
    Scanner.ExpectSymbol(52); (*{0516-0518} *)
    Express.GetConstVal; (*{051b} *)
    Words(t)^[2] := Express.curDesc.raw[0]; (*{051d-0521} FIXME pun *)
    Words(t)^[6] := Express.curDesc.raw[2]; (*{0522-0528} dword spill idealized *)
    IF (Words(t)^[2] = Compiler.charArrayDesc) AND (NOT Compiler.compilationActive)
       AND (Words(t)^[6] = 0) THEN (*{0529-0537} FIXME: compilationActive BOOLEAN vs 0 *)
      OpenScopeEmit(t); (*{053a} *)
    END;
    Scanner.InsertSymbol(t); (*{053c-0541} FIXME: T1 pun *)
    Scanner.ExpectSymbol(9); (*{0542} *)
  END;
END ParseVarParam;

(* proc22 @0548 — ~ParseFieldList. 0 formals. *)
PROCEDURE ParseFieldList;
VAR saveScope: ADDRESS; tag, fld: CARDINAL;
    node: ADDRESS;
BEGIN
  saveScope := ADDRESS(SymTab.currentScope); (*{054a-0550} FIXME pun *)
  IF Scanner.curSymbol = 0 THEN (*{054e-0551} *)
    Scanner.NeedIdentifier; tag := CARDINAL(Scanner.curNode); (*{0553-0556} FIXME *)
    IF Scanner.TestSymbolInSet(6) THEN (*{0558?} FIXME: group wove word13/identKind guards; shape TBD *)
      Scanner.GetSym;
      Scanner.ExpectSymbol(52);
      fld := CARDINAL(ParseValParam()); (*{056d-0570} FIXME *)
      Words(ADDRESS(tag))^[2] := fld; (*{0571-0579} FIXME *)
    ELSE
      tag := CARDINAL(Scanner.MakeIdentifierNode(3)); (*{05b9-05bd} FIXME *)
      IF Compiler.compilationActive AND (Scanner.curSymbol = 9) THEN (*{05be-05c6} *)
        fld := CARDINAL(Scanner.NewSizedNode(6)); Words(ADDRESS(fld))^[3] := 2; (*{05c8-05ce} FIXME *)
      ELSE
        Scanner.ExpectSymbol(52); (*{05d1-05d3} *)
        fld := CARDINAL(ParseValParam()); (*{05d5-05d8} *)
      END;
      Words(ADDRESS(tag))^[2] := fld; (*{05d9-05db} FIXME *)
      Scanner.InsertSymbol(ADDRESS(tag)); (*{05dc-05dd} FIXME T1 pun *)
    END;
    Scanner.ExpectSymbol(9); (*{05e0} *)
  ELSE
    tag := CARDINAL(SymTab.currentScope); node := saveScope; (*{05ed-05f1} FIXME *)
    WHILE ADDRESS(tag) # node DO (*{05f1-0605} FIXME *)
      IF ADDRESS(tag) = NIL THEN Errors.ReportErrorWithText(5, Scanner.tokenBuffer); END; (*{05f9-0600} *)
      tag := CARDINAL(Words(ADDRESS(tag))^[0]); (*{0602-0604} FIXME *)
    END;
  END;
END ParseFieldList;

(* proc23 @060a — ~EvalConstExpr. 0 formals. Const-expr list evaluator. *)
PROCEDURE EvalConstExpr;
VAR t, u, v: CARDINAL;
    n: CARDINAL;
BEGIN
  WHILE Scanner.curSymbol = 0 DO (*{060c-0682} *)
    t := CARDINAL(SymTab.currentScope); (*{0611-0613} FIXME *)
    Scanner.DeclareIdentifier(4); u := CARDINAL(Scanner.curNode); (*{0615-0619} FIXME *)
    Words(ADDRESS(u))^[4] := Express.spillFlag; (*{061b-061d} FIXME *)
    IF Scanner.AcceptSymbol(44) THEN (*{061e-0622} *)
      Express.GetConstVal; (*{0624} *)
      Express.ConstToCard(Compiler.CardType, 44); (*{0626-062a} FIXME: (type,code) vs DEF order *)
      Words(ADDRESS(u))^[2] := Express.curDesc.raw[2]; (*{062b-062f} FIXME *)
      Words(ADDRESS(u))^[3] := 256; (*{0631-0637} *)
      Scanner.ExpectSymbol(6); (*{0638} *)
    END;
    IF NOT (Scanner.TestSymbolInSet(6) AND Scanner.AcceptSymbol(1)) THEN EXIT END; (*{0639-0640} FIXME shape *)
    Scanner.GetSym; (*{0642} *)
    v := CARDINAL(ParseFormalParams()); (*{0644-0647} FIXME *)
    IF Words(ADDRESS(v))^[4] > 9 THEN n := 2; ELSE n := (Words(ADDRESS(v))^[3] + 1) DIV 2; END; (*{0648-0659} FIXME *)
    TypeSizeRec(ADDRESS(t), ADDRESS(u), ADR(SymTab.stringPoolPtr), ADDRESS(v), n); (*{065a-0662} FIXME: 5-arg punned shape *)
    Scanner.ExpectSymbol(9); (*{0664} *)
    IF Express.spillFlag = 0 THEN (*{0667-066d} *)
      IF SymTab.stringPoolPtr <= 510 THEN Express.CentralError(TRUE, 83); END; (*{066c-0674} FIXME cond *)
    ELSE
      IF SymTab.stringPoolPtr >= 384 THEN Express.CentralError(TRUE, 81); END; (*{0678-0680} FIXME cond *)
    END;
  END;
END EvalConstExpr;

(* proc24 @0687 — ~CheckConformant. 0 formals, returns ADDRESS. *)
PROCEDURE CheckConformant(): ADDRESS;
VAR t: ADDRESS;
BEGIN
  IF Scanner.AcceptSymbol(47) THEN (*{0689-068d} *)
    Scanner.ExpectSymbol(41); (*{068f-0691} *)
    t := Scanner.NewSizedNode(11); (*{0693-0695} *)
    CheckConformantTail(t); (*{0697-0699} FIXME: self/nested-variant TBD *)
  ELSE
    t := GetIdent(); (*{069e-06a0} *)
  END;
  RETURN t; (*{06a3} *)
END CheckConformant;

(* proc14 @06a7 — ~ParseRecordType (map name). 3 formals. *)
PROCEDURE ParseRecordType(rec: ADDRESS; VAR size: CARDINAL; tag: CARDINAL);
VAR total: CARDINAL;
    fld, head, cur: ADDRESS;
    disc, code: CARDINAL;
    lo, hi: CARDINAL;
BEGIN
  total := 6; size := 0; (*{06a9-06b0} *)
  IF Scanner.curSymbol # 9 THEN (*{06b1-06b5} *)
    Scanner.ExpectSymbol(43); (*{06b7-06b9} *)
    IF NOT Scanner.AcceptSymbol(5) THEN GOTO noFixed END; (*{06bb-06bf} *)
    Scanner.OpenScope(SymTab.currentScope, NIL); (*{06c1-06c4} FIXME args *)
    IF Scanner.AcceptSymbol(20) THEN code := 24; ELSE code := 8; END; (*{06c7-06d3} *)
    IF tag # 0 THEN (*{06d4} *)
      fld := Scanner.NewNode(4); (*{06d7-06d9} *)
      Words(fld)^[1] := SymTab.currentScope; Words(fld)^[0] := SymTab.currentScope; (*{06db-06e3} FIXME T1 pun *)
      Words(fld)^[3] := code; disc := 1; hi := 34; (*{06e4-06eb} *)
    ELSE
      Scanner.DeclareIdentifier(4); fld := Scanner.curNode; (*{06ee-06f2} FIXME T1 pun *)
      Words(fld)^[3] := code; Words(fld)^[6] := Express.spillFlag + 1; (*{06f3-06fb} FIXME *)
      IF NOT (Scanner.TestSymbolInSet(6) AND Scanner.AcceptSymbol(1)) THEN EXIT END; (* FIXME shape *)
      Scanner.GetSym; disc := 9; hi := 544; (*{0704-070b} *)
    END;
  fixedLoop:
    head := CheckConformant(); (*{070c} *)
    cur := fld;
    WHILE cur # rec DO cur := Words(cur)^[0]; END; (*{0711-071b} *)
    rec := fld; (*{071d-071f} *)
    IF NOT Scanner.TestSymbolInSet(hi) THEN GOTO doneVariants END; (*{0720-0726} FIXME set TBD *)
    Scanner.GetSym; (*{0729} *)
    IF fld # NIL THEN (*{072b-072d} *)
      fld := Words(fld)^[2]; head := fld; (*{072f-0733} *)
      IF (4 IN Words(fld)^[3]) OR (Words(head)^[4] > 9) THEN (*{0734-073c} FIXME set TBD *)
        code := 2; (*{073e-073f} *)
        REPEAT
          head := Words(head)^[5]; (*{0746-074c} FIXME: ConstToIntRange idealized *)
        UNTIL FALSE;
      ELSE
        code := (Words(head)^[3] + 1) DIV 2; (*{0751-0758} *)
      END;
    END;
    SymTab.currentScope := SymTab.currentScope; (*{0765-0768} self-store? slot shuffle FIXME *)
  noFixed:
    IF Scanner.AcceptSymbol(2) THEN (*{076a-076d} *)
      disc := CARDINAL(GetIdent()); (*{076f-0772} FIXME *)
      Express.MatchOpClass(BITSET{511}, 2); (*{0773-077b} *)
      size := disc; (*{077d-077f} *)
    END;
  doneVariants: ;
END ParseRecordType;

(* proc25 @0783 — ~CloseScopeFixup. 0 formals. *)
PROCEDURE CloseScopeFixup;
BEGIN
  IF 0 IN Scanner.curSymbol THEN (*{0785-078a} FIXME: CARDINAL set test *)
    Texts.WriteString(3, ""); (*{078c-0791} FIXME: proc21 args TBD *)
    Texts.WriteString(3, Scanner.tokenBuffer); (*{0793-0798} FIXME *)
    Texts.WriteLn(3); (*{079a-079c} FIXME *)
  END;
  INC(nestDepth); (*{079d-079f} FIXME: group used Pass1.tempDepth *)
END CloseScopeFixup;
(* PASS1 group 3 @07a8-end. Missing/stubbed: proc10/11/26/27/29/30 (no bytes),
   proc36 body (patched over), PASS1/4NAZBA (no bytes). DISPUTE: proc9 =
   ParseProcBody per body (no file calls) vs ~WriteSymFile per map. *)

(* FIXME-NYC stubs for called-but-absent procedures *)
PROCEDURE EmitModuleProlog(node: ADDRESS); FORWARD; (* proc10: 1 push *)
PROCEDURE ParseDeclSync; FORWARD; (* proc11: 0 pushes *)
PROCEDURE ParseConstOrTypeArm; FORWARD; (* proc26: DCL arm 111 *)
PROCEDURE ParseModuleArm; FORWARD; (* proc27: DCL arm 112 *)
PROCEDURE TryParseDecl(tag: CARDINAL): BOOLEAN; FORWARD; (* proc29: 1 push; 2-push sites FIXME *)
PROCEDURE ParseImportScope; FORWARD; (* proc30: display-only *)

(*{07a8} PROCDE — ParseProcedureDecl. 0 params. *)
PROCEDURE ParseProcedureDecl;
VAR l2, l3, l4, l5: ADDRESS; s0, s1, s2, s3, s5, s6: WORD;
BEGIN
  CloseScopeFixup; (*{07aa} proc25 *)
  Scanner.NeedIdentifier; (*{07ad} *)
  IF (Scanner.word13 = SymTab.currentScope) & (Compiler.scopeSpare3 = NIL) & (5 IN Scanner.followSet) THEN (*{07af-07bf} FIXME codes *)
    l3 := Scanner.curNode; (*{07c1-07c3} FIXME pun *)
    Scanner.Allocate(ADR(l2), 14); (*{07c4-07c7} FIXME: group wrote Proc7 *)
    MOVE(l3, l2, 14); (*{07c9-07cc} FIXME dst/src order *)
    Scanner.GetSym; (*{07d6} *)
  ELSE
    l2 := Scanner.DeclareIdentifier(5); (*{07da-07de} *)
    Words(l2)^[5] := PushTempMark(); (*{07df-07e4} FIXME pun *)
    Words(l2 + 1)^[5] := Express.spillFlag; (*{07e5-07eb} FIXME cell *)
  END;
  Scanner.GetStackMark(ADR(l6)); (*{07ec-07ee} FIXME slot *)
  ParseRecordType(l2 + 6, l2 + 2, 0); (*{07f0-07f8} FIXME: ADDRESS arith + (rec,size,tag) roles *)
  Scanner.ExpectSymbol(9); (*{07fa-07fb} *)
  IF 5 IN Words(l2)^[3] THEN (*{07fd-0801} FIXME: group ternary w/ s3 TBD *)
    Express.CentralError(TRUE, 68); (*{080f-0814} FIXME: Proc21 8-cell call TBD *)
    WHILE l4 # NIL DO (*{0816-082f} formal walk FIXME *)
      Express.CentralError(TRUE, 68); (*{081a-0827} FIXME: Proc23 5-push call TBD *)
      l4 := Words(l4)^[0];
    END;
    Words(l2)^[3] := Words(l2)^[3] - BITSET{5}; (*{0831-0838} *)
    Scanner.CheckStackMark(l2 + 14); (*{0839-083c} FIXME arith *)
    ParseProcBody(l2); (*{0843} `f9 proc9` *)
  ELSE
    IF Compiler.scopeSpare3 = NIL THEN (*{0846-0849} *)
      IF Scanner.AcceptSymbol(67) THEN (*{084b-084e} FIXME: 67=END? *)
        s3 := 32; (*{0851-0856} FIXME *)
        Scanner.ExpectSymbol(9); (*{0856} *)
      ELSE
        ParseProcBody(l2); (*{085a-085b} *)
        InsertSetConst(NIL, 0); (*{085c-085e} FIXME args *)
      END;
    END;
  END;
  DEC(nestDepth); (*{085f-0861} *)
END ParseProcedureDecl;

(*{0878} MODULD — ParseModuleHead. 0 params. *)
PROCEDURE ParseModuleHead;
VAR l2, l3: ADDRESS;
BEGIN
  CloseScopeFixup; (*{087d} *)
  l3 := ADDRESS(Statemen.withPending); (*{087e-087f} FIXME pun *)
  l2 := Scanner.DeclareIdentifier(6); (*{0880-0884} *)
  IF Scanner.AcceptSymbol(44) THEN (*{0885-0887} FIXME: 44 here? *)
    Statemen.withPending := 1; (*{088b-088c} *)
    Express.EvalConstExpr; (*{088d} FIXME: group saw proc13=GetConstVal *)
    Scanner.ExpectSymbol(6); (*{088f-0891} *)
  END;
  Scanner.ExpectSymbol(9); (*{0893-0894} *)
  EmitModuleProlog(l2); (*{0896-0897} FIXME-NYC *)
  Statemen.withPending := CARDINAL(l3); (*{0898-0899} FIXME *)
  DEC(nestDepth); (*{089b-089d} *)
END ParseModuleHead;

(*{08b2} proc28 — ParseExportList. 0 params. From DCL arm 104. *)
PROCEDURE ParseExportList;
VAR l2: ADDRESS; l3: WORD;
BEGIN
  l2 := Scanner.DeclareIdentifier(2); (*{08b4-08b8} *)
  l3 := PushTempMark(); (*{08b9-08ba} FIXME: WORD := CARDINAL pun *)
  IF Compiler.scopeSpare3 = NIL THEN (*{08be-08c1} *)
    CodeGen.OpenFixup(1, l3, 0); (*{08c3-08c6} FIXME: (pos?,...) arity *)
    Words(emitBase)^[CARDINAL(l3)] := CodeGen.nextEmitPos; (*{08c9-08cd} FIXME *)
    Scanner.EmitString(l2, s1, 128); (*{08ce-08d2} FIXME-NYC: no such export; module suspect *)
    CodeGen.EmitConst(l2); (*{08d5} FIXME-NYC *)
    CodeGen.EmitConst2(l2, s1); (*{08d7-08d9} FIXME-NYC *)
  END;
  Scanner.TestSymbolInSet(514); (*{08dc-08df} FIXME: CARDINAL set pun *)
  WHILE NOT Scanner.AcceptSymbol(1) DO (*{08e1-08e5} FIXME loop shape *)
    Scanner.GetSym; (*{08e7} *)
  END;
END ParseExportList;

(*{08f1} DCL — ParseOneDecl. 0 params. Dispatch on saved curSymbol. *)
PROCEDURE ParseOneDecl;
VAR l2: CARDINAL; l3: ADDRESS; l4: WORD;
BEGIN
  l4 := Express.spillFlag; (*{08f3-08f5} FIXME: group wrote word4 *)
  l3 := SymTab.currentScope; (*{08f6-08f8} FIXME T1 pun *)
  l2 := Scanner.curSymbol; (*{08f9-08fc} *)
  Scanner.GetSym; (*{08fd} *)
  CASE l2 OF (*{08fe-0913} callswitch 104..112 *)
     104: ParseExportList(); (*{0901} *)
  |  108: ParseValParam(); (*{0904} FIXME: VALUE-parser as CONST arm? *)
  |  110: EvalConstExpr(); (*{0907} FIXME: const-EVAL as VAR arm? *)
  |  109: ParseFieldList(); (*{090a} FIXME: field-parser as TYPE arm? *)
  |  111: ParseConstOrTypeArm(); (*{090d} FIXME-NYC *)
  |  112: ParseModuleArm(); (*{0910} FIXME-NYC *)
  END;
  Express.spillFlag := l4; (*{092d-092e} FIXME type *)
  SymTab.currentScope := l3; (*{0930-0931} FIXME pun *)
END ParseOneDecl;

(*{0943} DCLS — ParseDeclarations. 1 param, BOOLEAN function. *)
PROCEDURE ParseDeclarations(follow: BITSET): BOOLEAN;
VAR l2: CARDINAL; l3: CARDINAL; l4: CARDINAL; l5: CARDINAL;
    l6: ADDRESS; l7: ADDRESS;
BEGIN
  l2 := CARDINAL(Scanner.scanOptions); (*{0945-0947} FIXME pun *)
  l3 := Scanner.tokenPos; (*{0948-094b} FIXME: group wrote word25 *)
  Scanner.GetStackMark(ADR(l6)); (*{094c-094e} *)
  l5 := CodeGen.nextEmitPos; (*{0950-0952} FIXME: group wrote word2 *)
  l7 := SymTab.currentScope; (*{0953-0956} FIXME pun *)
  l4 := SymTab.moduleCount + SymTab.stringPoolPtr * 128; (*{0957-095e} FIXME: group packed word4+word5 *)
  IF (Scanner.curSymbol = 13) OR (Scanner.curSymbol = 23) THEN (*{095f-096a} FIXME codes *)
    Statemen.GuardedStatSeq(follow); (*{096c-096d} *)
  ELSE
    Scanner.TestSymbolInSet(2018); (*{0971-0974} FIXME: CARDINAL set pun *)
    ParseDeclSync(); (*{0976} *)
    WHILE NOT TryParseDecl(follow) DO END; (*{0977-097a} FIXME polarity *)
  END;
  RETURN TRUE; (*{097c-097d} *)
  (* guarded-recovery handler: *)
  SymTab.moduleCount := l4 MOD 256; (*{097f-0983} FIXME *)
  AllocSymEntry((l4 DIV 256) * 2); (*{0984-098a} FIXME role *)
  IF Errors.savedEditPos > l3 THEN (*{098d-0993} FIXME: group wrote word2 *)
    Scanner.tokenPos := l3; (*{0995-0996} *)
    Scanner.scanOptions := BITSET(l2); (*{0999-099a} FIXME *)
    CodeGen.nextEmitPos := l5; (*{099c-099d} FIXME: assignable? *)
    Scanner.CheckStackMark(l6); (*{099f-09a0} *)
    Errors.RollbackToMark; (*{09a2} *)
    CodeGen.OpenEmitter; (*{09a4} *)
    RETURN FALSE; (*{09a7-09a8} *)
  END;
END ParseDeclarations;

(*{09b9} IMEXDC — ParseImportFrom. 0 params. *)
PROCEDURE ParseImportFrom;
BEGIN
  IF (Scanner.curSymbol = 15) OR (Scanner.curSymbol = 16) THEN (*{09bb-09c6} FIXME codes *)
    SymTab.DefineDefinitionModule(0); (*{09c8-09cc} FIXME: 2 pushes vs 1 formal *)
    ParseImportScope(); (*{09ce-09cf} FIXME-NYC *)
  ELSIF (Scanner.curSymbol = 23) OR (Scanner.curSymbol = 13) THEN (*{09d3-09de} *)
    Statemen.GuardedStatSeq(BITSET{}); (*{09e0-09e2} FIXME: extra push TBD *)
  ELSE
    Scanner.TestSymbolInSet(2046); (*{09e6-09e9} FIXME pun *)
    IF Scanner.curSymbol = 17 THEN (*{09eb-09ef} *)
      SymTab.DefineProgramModule(0); (*{09f2-09f9} FIXME: 6 pushes vs 1 formal *)
    ELSE
      ParseDeclSync(); (*{09fd} *)
    END;
    WHILE NOT TryParseDecl(0) DO END; (*{09fe-0a02} FIXME: extra (ix) push *)
  END;
END ParseImportFrom;

(*{0a0c} MODBLO — ParseModuleBlock. 1 param (module node). *)
PROCEDURE ParseModuleBlock(modNode: ADDRESS);
VAR l2: ADDRESS; l3: ADDRESS;
    l4: ADDRESS; l5: WORD;
BEGIN
  l2 := SymTab.currentScope; (*{0a0e-0a10} FIXME pun *)
  l3 := SymTab.ownNamePtr; (*{0a11-0a13} FIXME: group wrote word11 *)
  SymTab.ownNamePtr := NIL; (*{0a14-0a15} FIXME *)
  Scanner.OpenScope(SymTab.currentScope, NIL); (*{0a17-0a1a} FIXME args *)
  Scanner.GetStackMark(ADR(l5)); (*{0a1d-0a1f} FIXME slot *)
  ParseImportScope(); (*{0a21} *)
  Scanner.GetSym; (*{0a23} *)
  l4 := SymTab.ownNamePtr; (*{0a25-0a27} FIXME *)
  SymTab.ownNamePtr := l3; (*{0a28-0a29} FIXME *)
  IF TRUE THEN (*{0a2b-0a2f} FIXME: 10 IN NodeFlagSet(modNode, s3) *)
    SymTab.InitSymbolTables(BITSET{}, l4, modNode); (*{0a34-0a39} FIXME: 4-5 pushes vs 3 formals *)
  ELSE
    SymTab.InitSymbolTables(BITSET{}, l4, l2); (*{0a3d-0a42} FIXME *)
  END;
  SymTab.currentScope := l2; (*{0a44-0a45} FIXME pun *)
END ParseModuleBlock;

(*{0a56} proc9 — ParseProcBody (DISPUTE: map said ~WriteSymFile, but body
  parses decls + body block per procedure and issues NO file calls). *)
PROCEDURE ParseProcBody(procNode: ADDRESS);
VAR l2: CARDINAL; l3: ADDRESS; l4: CARDINAL;
BEGIN
  Scanner.GetStackMark(ADR(l3)); (*{0a58-0a5a} *)
  l2 := SymTab.stringPoolPtr; (*{0a5c-0a5e} FIXME: group wrote word5 *)
  SymTab.stringPoolPtr := 510; (*{0a5f-0a62} FIXME pun *)
  Scanner.OpenScope(SymTab.currentScope, procNode); (*{0a64-0a68} FIXME: 3rd push TBD *)
  Express.spillFlag := Express.spillFlag + 1; (*{0a6b-0a6d} FIXME: group wrote word4 *)
  Scanner.PushWithScope; (*{0a70} *)
  IF Scanner.curSymbol = 0 THEN (*{0a72?} FIXME: group wove word10/9/8 guard; shape TBD *)
    Statemen.GuardedStatSeq(BITSET{}); (*{0a85-0a86} FIXME arg *)
  ELSE
    l4 := 0; (*{0a8f-0a90} *)
    (*{0a91-0aa9} NUL-terminated name scan FIXME *)
    (*{0aab-0ab8} IF name = "CODE" THEN Errors.ReportError(11) FIXME callee *)
    WHILE NOT TryParseDecl(0) DO END; (*{0abd-0ac0} FIXME arg *)
  END;
  Scanner.GetSym; (*{0ac2} *)
  Express.spillFlag := Express.spillFlag - 1; (*{0ac9-0acc} FIXME *)
  SymTab.stringPoolPtr := l2; (*{0ace-0acf} FIXME *)
  Scanner.CheckStackMark(l3); (*{0ad1-0ad2} *)
  Words(emitBase)^[0] := Scanner.codeSize; (*{0ad4-0ade} FIXME: indexed-emit shape *)
END ParseProcBody;

(*{0ae5} MAINDE — ParseMainModule. 0-param BOOLEAN function. *)
PROCEDURE ParseMainModule(): BOOLEAN;
VAR l2: ADDRESS; l3: ADDRESS;
    l4: ADDRESS; l5: ADDRESS;
    l6: CARDINAL; l7: CARDINAL;
    l8, l10: CARDINAL; l9: ADDRESS;
BEGIN
  Scanner.GetStackMark(ADR(l9)); (*{0af1-0af3} *)
  Scanner.AcceptSymbol(25); (*{0af5-0af7} *)
  l6 := ORD(NOT Compiler.scopeSpare3) AND ORD(Scanner.AcceptSymbol(24)); (*{0af9-0b0d} FIXME shape *)
  Scanner.ExpectSymbol(22); (*{0b0e-0b10} *)
  l7 := 0; (*{0b12-0b13} *)
  l3 := Scanner.MakeIdentifierNode(5); (*{0b4e-0b52} *)
  IF Scanner.AcceptSymbol(44) THEN (*{0b53-0b55} FIXME: 44 here? *)
    IF Statemen.withPending # 0 THEN (*{0b59-0b5b} *)
      Scanner.ExpectIdentKind(1); Scanner.GetSym; (*{0b5d-0b60} *)
      Scanner.ExpectSymbol(6); (*{0b62-0b63} *)
    END;
  END;
  Scanner.ExpectSymbol(9); (*{0b65-0b66} *)
  Scanner.TestSymbolInSet(2031); (*{0b68-0b6b} FIXME pun *)
  IF Compiler.scopeSpare3 OR (l6 # 0) OR (Scanner.curSymbol - 13 IN BITSET{0..12}) THEN (*{0b6d-0b7a} FIXME *)
    CASE CARDINAL(0) OF (*{0ba1} FIXME: Loader.Proc5()+1 DIV 2 dispatch, codes 92/93/94 *)
       92: SymTab.CompileDispatch(l2, TRUE, l6 # 0); (*{0b83-0b8c} FIXME: 5 pushes vs 3 formals *)
    |  93: SymTab.CompileDispatch(l2, TRUE, l6 # 0); (*{0b8d-0b96} FIXME *)
    |  94: SymTab.CompileDispatch(l2, TRUE, l6 # 0); (*{0b97-0ba0} FIXME *)
    ELSE    SymTab.CompileDispatch(l2, TRUE, l6 # 0); (*{0bae-0bb5} FIXME *)
    END;
  END;
  CodeGen.InitCodeGenerator; (*{0bb7} *)
  IF Compiler.scopeSpare3 = NIL THEN (*{0bba-0bbd} *)
    Compiler.compilationActive := FALSE; (*{0bbf-0bc1} FIXME: group gated on l6 *)
    l4 := SymTab.currentScope; (*{0bc6-0bc9} FIXME pun *)
    WHILE l4 # NIL DO (*{0bca-0c43} export-emit walk *)
      IF Words(l4)^[4] = 6 THEN (*{0bd0-0bd2} *)
        l5 := Words(l4)^[6]; (*{0bd4-0bd6} FIXME pun *)
        WHILE l5 # NIL DO (*{0bd7-0be7} *)
          OpenScopeEmit(l5); (*{0be2-0be5} *)
          l5 := Words(l5)^[0]; (*{0be6-0be8} *)
        END;
      ELSIF Words(l4)^[2] = Compiler.charArrayDesc THEN (*{0beb-0bef} FIXME pun *)
        OpenScopeEmit(l4); (*{0bf2-0bf3} *)
      ELSIF (Words(l4)^[4] = 2) THEN (*{0bf6-0c03} FIXME: bit-66 conjunct TBD *)
        CodeGen.OpenFixup(1, Words(l4)^[5], 0); (*{0c05-0c09} FIXME arity *)
        Words(emitBase)^[Words(l4)^[5]] := CodeGen.nextEmitPos; (*{0c0c-0c11} FIXME *)
      ELSIF (Words(l4)^[4] = 4) AND (Words(l4)^[2] > 9) AND (Words(l4)^[3] = 0) THEN (*{0c22-0c33} *)
        PopTempMark(Words(l4)^[5], 0); (*{0c35-0c3f} FIXME: 8-cell grouping *)
      END;
      l4 := Words(l4)^[0]; (*{0c40-0c42} *)
    END;
    IF (Scanner.curSymbol # 23) AND (Scanner.curSymbol # 13) THEN (*{0c45-0c50} *)
      WHILE NOT TryParseDecl(0) DO END; (*{0c52-0c55} FIXME arg *)
    ELSE
      Statemen.GuardedStatSeq(BITSET{}); (*{0c59-0c5a} FIXME arg *)
    END;
    Words(emitBase)^[0] := Scanner.codeSize; (*{0c5c-0c61} FIXME shape *)
  END;
  RETURN TRUE; (*{0c62-0c63} *)
  (* guarded-recovery handler: *)
  IF Errors.savedEditPos > l10 THEN (*{0c65-0c69} FIXME: group wrote word2; l10 uninit here TBD *)
    Scanner.tokenPos := l10; Scanner.scanOptions := BITSET(l8); (*{0c6b-0c70} FIXME *)
    Scanner.CheckStackMark(l9); (*{0c72} *)
    Errors.RollbackToMark; (*{0c75} *)
    CodeGen.OpenEmitter; (*{0c77} *)
    RETURN FALSE; (*{0c7a-0c7b} *)
  END;
  Errors.DoError("X"); (*{0c84-0c86} FIXME: group saw proc17(69); unmapped *)
END ParseMainModule;

(*{0c93} proc33 — WriteMcdHeader. 0 params. *)
PROCEDURE WriteMcdHeader;
VAR l2: CARDINAL; l3: ADDRESS;
BEGIN
  Scanner.Allocate(l3, 16); (*{0c95-0c98} FIXME: group wrote Reserve *)
  l2 := SymTab.moduleCount + 1; (*{0c99-0c9c} FIXME: group wrote word4 *)
  WHILE l2 # 0 DO (*{0c9d-0caa} *)
    DEC(l2);
    CodeGen.CloseFixup(Words(emitBase)^[l2], 0); (*{0ca4-0ca8} FIXME pun *)
  END;
  IF CodeGen.windowBase = 0 THEN (*{0cd2-0cd5} FIXME: group wrote word3 *)
    MOVE(Scanner.codeBuffer, l3, 16); (*{0cd7-0cdc} FIXME dst/src order *)
  END;
  IF Compiler.rangeCheckEnabled = FALSE THEN (*{0cef-0cf1} FIXME: group wrote word2 *)
    Texts.WriteString(3, "Compiled bytes:"); (* FIXME *)
    Texts.WriteCard(3, CodeGen.nextEmitPos - 16, 6); (* FIXME *)
    Texts.WriteLn(3); (* FIXME *)
  END;
END WriteMcdHeader;

(*{0d17} proc35 — EmitConstVal. 2 params: (buf, count) per frame rule. *)
PROCEDURE EmitConstVal(buf: ADDRESS; count: CARDINAL);
BEGIN
  WHILE count # 0 DO (*{0d19-0d1b} *)
    CodeGen.EmitString(buf); (*{0d1d-0d1f} FIXME-NYC: group saw Proc3 *)
    buf := buf + 2; (*{0d21-0d24} FIXME: ADDRESS arith *)
    count := count - 2; (*{0d25-0d28} *)
  END;
END EmitConstVal;

(*{0d2e} proc34 — EmitTypeDesc. 0 params. *)
PROCEDURE EmitTypeDesc;
VAR l2: ADDRESS; l3: ADDRESS;
    l4, l5, l6: CARDINAL;
BEGIN
  Scanner.Allocate(l2, 84); (*{0d30-0d32} FIXME: group wrote Reserve *)
  Scanner.Allocate(l3, 508); (*{0d34-0d38} FIXME *)
  l5 := CodeGen.nextEmitPos - 18; (*{0d39-0d3d} *)
  l6 := 2 * (32 - SymTab.moduleCount); (*{0d70-0d76} FIXME: group wrote word3 *)
  EmitConstVal(l2 + l6, 84 - l6); (*{0d78-0d7f} FIXME arith *)
  LinkSymEntry(l3); (*{0d81-0d82} *)
  EmitConstVal(l3, SymTab.stringPoolPtr - 4); (*{0d83-0d88} FIXME: group wrote word5 *)
  l4 := SymTab.moduleCount; (*{0d8a-0d8c} FIXME *)
  WHILE l4 # 0 DO (*{0d8d-0da7} per-scope emit loop *)
    DEC(l4);
    EmitConstVal(SymTab.moduleTable + l4 * 10, 10); (*{0d94-0d9b} FIXME: word6 base? *)
    CodeGen.EmitString(l5 + (SymTab.moduleCount - l4) * 2); (*{0d9d-0da5} FIXME-NYC: group saw Proc3 *)
  END;
  CodeGen.EmitString(0); (*{0da9-0daa} FIXME *)
  CodeGen.EmitString(0); (*{0dac-0dad} FIXME *)
END EmitTypeDesc;

(*{0e93} proc36 — CheckForwardResolved: NO BODY (slot patched over by the
  COMPILE link stub's keyword-table search). Reconstruct from SymTab.CheckForwards
  or another MCD. *)
PROCEDURE CheckForwardResolved; FORWARD;

(*{1027} PASS1 — Pass1Main: NO bytes in pass1.txt (ends ~101a). *)
PROCEDURE Pass1Main; FORWARD;

(*{105b} 4NAZBA — module init: NO bytes. *)
PROCEDURE InitPass1; FORWARD;

END Pass1.