T/%LINE/ B/LINE/DIAG/ T+1 R/DUMP/DIAGNAMETABLE/
T/PROGRAM DIAGNOSTICS/ R/DIAGNOSTICS/ICL9LPPMPACKAGE/
T/CONST/
TS/MODEWORDOFFSET/ R/20/12/ T+1 R/24/16/ T+1 R/76/60/ T+1
I/   PAGEFLAGOFFSET = 228;///
T/TYPE/
TS/SYMBOLTYPE =/ TC/PERIOD,/ A/PERIOD,/DOTDOT,/
T/FUNCTION SPACELEFT :/
I$FUNCTION ATLEFTMARGIN : BOOLEAN;
    
    BEGIN
    ATLEFTMARGIN := COLUMNINDEX=TOTALINDENT;
    END (* ATLEFTMARGIN *);
   
FUNCTION SPACEINFRESHLINE : COLUMNRANGE;
   
    BEGIN
    SPACEINFRESHLINE := MAXCOLUMN-TOTALINDENT+1;
    END (* SPACEINFRESHLINE *);
    
$
T/FUNCTION CONVERTEDCHAR (/ TS/UNDEFINEDCHAR/ B/26// P.E
I/0;   (* NULL (IN EBCDIC OR ISO) *)/
TS/ELSE/ T+1 P+1
I$      BEGIN
      CASE CHARCODEUSED OF
         CCICL1900: ;
        CCINVALID: ORDINALVALUE:=UNDEFINEDCHAR;
        CCEBCDIC: (* TOO FIDDLY TO DO PROPERLY NOW *);
        CCISO:  IF (ORDINALVALUE<ORD(BLANK)) OR (ORDINALVALUE=MAXORDCHAR) THEN
                   ORDINALVALUE:=UNDEFINEDCHAR;
        END (*CASE*);
      CONVERTEDCHAR:=CHR(CHARMAP@[ORDINALVALUE]);
      END;
$
T/PROCEDURE P77RESETMAPAREA;/ R/P77RESETMAPAREA/ICL9LPRESETPMMAP/
T/FUNCTION P77NEXTMAPREC :/ R/P77NEXTMAPREC/ICL9LPNEXTPMMAP/
T/PROCEDURE DESCRIBEBLOCK;/
I$FUNCTION ICL9LPPRELINKPM : BYTENUMBER;
    EXTERN;
   
FUNCTION ICL9LPPOSTLINKPM : BYTENUMBER;
    EXTERN;
     
$
T/PROCEDURE FINDLOCUSOFCONTROL (/ B/CODE/ORIGINAL/
TS/OFFSETATEND/ I/        CODEOFFSET,///
TC/P77/ R/P77NEXTMAPREC/ICL9LPNEXTPMMAP/ T+1
TS/P77/ R/P77RESETMAPAREA/ICL9LPRESETPMMAP/
T/%NEWPAGE/ I$
    PROCEDURE RESETMAPSCAN (NEWCODEOFFSET : BYTENUMBER);
    (******** IMPLEMENTATION-DEPENDENT ********)
     
        BEGIN
        CODEOFFSET := NEWCODEOFFSET;
        WITH BLOCK DO
           BEGIN
           IDENTIFICATION := BYOFFSET;
           OFFSET := CODEOFFSET;
           KIND :=  UNKNOWNBLOCK;
           END;
        SOURCELINE := 0;
        OFFSETATENDOFLINE := 0;
        ENDOFMAP := FALSE;
        ICL9LPRESETPMMAP;
        END (* RESETMAPSCAN *) ;
$
TS/PROCEDURE DECODEMAPENTRY;/
TS/VAR/
I$        CONST
           MAPESCAPE = 0;
           MAPPEDBLOCK = 0;
           MAPPEDJLKTASK = 1;
   
$
TS/P, Q/ B/P// P.E I/BASE, FENCE, LIMIT,/
TS/BEGIN/
I$        PROCEDURE GETMAPINTEGER (VAR N : INTEGER);
           VAR
              B : BYTE;
           BEGIN
           GETNEXTMAPENTRY;
           B := MAPENTRY;
           GETNEXTMAPENTRY;
           N := BYTESHIFT*B + MAPENTRY;
           END (* GETMAPINTEGER *);
     
$
TS/IF MAPENTRY=0/ PS/END (* =0 *)/ P+1
I$           IF MAPENTRY=MAPESCAPE THEN
              BEGIN
              GETNEXTMAPENTRY;
              IF MAPENTRY=MAPPEDBLOCK THEN
                 WITH BLOCK DO
                    IF OBJECTSAVAILABLE THEN
                       BEGIN
                       GETMAPINTEGER (SERIAL);
                       IDENTIFICATION := BYSERIAL;
                       END
                    ELSE
                       BEGIN
                       GETNEXTMAPENTRY;
                       IF MAPENTRY=ORD(PROGBLOCK) THEN
                          KIND := PROGBLOCK
                       ELSE IF MAPENTRY=ORD(PROCBLOCK) THEN
                          KIND := PROCBLOCK
                        ELSE IF MAPENTRY=ORD(FUNCBLOCK) THEN
                          KIND := FUNCBLOCK
                       ELSE
                          KIND := UNKNOWNBLOCK;
                       GETNEXTMAPENTRY;
                       IDENTIFICATION := BYNAME;
                       NAME := BLANKALFA;
                       FOR I := 1 TO MAPENTRY DO
                          BEGIN
                          GETNEXTMAPENTRY;
                          NAME[I] := CHR (MAPENTRY);
                          END;
                       END
              ELSE IF MAPENTRY=MAPPEDJLKTASK THEN
                 BEGIN
                 GETMAPINTEGER (BASE);
                 BASE := OFFSETATENDOFLINE + BYTESPERORDER*BASE;
                 GETMAPINTEGER (FENCE);
                 FENCE := BASE + BYTESPERORDER*FENCE;
                 GETMAPINTEGER (LIMIT);
                 LIMIT := FENCE + BYTESPERORDER*LIMIT;
                 OFFSETATENDOFLINE := LIMIT;
                 IF (BASE<=CODEOFFSET) AND (CODEOFFSET<FENCE) THEN
                    RESETMAPSCAN (ICL9LPPRELINKPM)
                 ELSE IF (FENCE<=CODEOFFSET) AND (CODEOFFSET<LIMIT) THEN
                    RESETMAPSCAN (ICL9LPPOSTLINKPM);
                 END
              ELSE
                 ENDOFMAP := TRUE;
              END (* =MAPESCAPE *)
$
TS/END (* <> 0/ R/ 0/MAPESCAPE/
TS/WITH BLOCK/ PS/IF LINEMAPAVAILABLE/
I/    RESETMAPSCAN (ORIGINALCODEOFFSET);///
-S/IF ENDOFMAP/ (D/  /, T+1) D/    /, T+1 PS/END (* FIND/
I$        RESETMAPSCAN (CODEOFFSET) ;
      END;
    IF BLOCK.IDENTIFICATION=BYSERIAL THEN
      DESCRIBEBLOCK;
$
T/PROCEDURE P77RESETOBJECTAREA/ R/P77RESETOBJECTAREA/ICL9LPRESETPMOBJ/
T/FUNCTION P77NEXTOBJECT/ R/P77NEXTOBJECT/ICL9LPNEXTPMOBJ/
T/%/ B/ENTRY/KEYED/
T/PROCEDURE P79INITDIAGTABLES/ R/P79INITDIAGTABLES/ICL9LPPMINITTABS/
TS/PROCEDURE INITDENOTATIONTABLES;/
TC/[PERIOD]./ T+1 P-1 R/PERIOD/DOTDOT/ R/'. /'../
TS/PROCEDURE GETNEXTOBJECT/ TC/P77/ R/P77NEXTOBJECT/ICL9LPNEXTPMOBJ/
TS/PROCEDURE GETFIRSTOBJECT/ TS/P77/ R/P77RESETOBJECTAREA/ICL9LPRESETPMOBJ/
TS/BEGIN (* CHECKOBJECTTABLE/ TS/VARIANTPART:/ TS/CHECKCLASS/
B/C// P.E I/IF OBJTAGFIELD<>NILSERIAL THEN/ T+1 P-1 I/  /
TS/BEGIN (* P79/ R/P79INITDIAGTABLES/ICL9LPPMINITTABS/
TS/END (* P79/ R/P79INITDIAGTABLES/ICL9LPPMINITTABS/
T/%/ B/ENTRY/KEYED/
TS/PROCEDURE WRITESTRINGSEGMENT (/  TS/BEGIN (* WRITEQUOTEDSTRING/
TS/ELSE/ PS/M := (S-2)/
I$                ELSE IF W<SPACEINFRESHLINE THEN
                  BEGIN
                  CONTINUE (DFILE);
                  WRITESTRINGSEGMENT (W, L, R);
                  END
                ELSE
                  BEGIN
                  IF NOT ATLEFTMARGIN THEN
                    BEGIN
                    CONTINUE (DFILE);
                    S := SPACELEFT;
                    END;
$
TS/BEGIN (* WRITE RECORD/
TS/WITH OBJECTTABLE[THISVARPART]@/ PS/WHILE LOOKINGFORVARIANT AND/
I$                      IF COMMAREQD THEN
                        BEGIN
                        WRITESEPARATOR(DFILE, 2);
                        SEPARATE;
                        END
                      ELSE COMMAREQD := TRUE;
                      WITH OBJECTTABLE[THISVARPART]@ DO
                        IF OBJTAGFIELD<>NILSERIAL THEN
                          WITH OBJECTTABLE[OBJTAGFIELD]@ DO
                            BEGIN
                            ACCESSFIELD(OBJOFFSET);
                            TAGVALUE := ORDINALCONTENTS(FIELDADDR);
                            MAKESPACEFOR(DFILE, 8);
                            WRITE (DFILE, 'VARIANT ');
                            WRITEVALUE (FIELDTYPE, FIELDADDR,
                                        FIELDTOBESEPARATED);
                            THISVARIANT :=
                               OBJECTTABLE[THISVARPART]@.OBJFSTVARIANT;
                            LOOKINGFORVARIANT := TRUE;
                            END
                        ELSE
                          BEGIN
                          LOOKINGFORVARIANT := FALSE;
                          THISVARIANT := NILSERIAL;
                          THISVARPART := NILSERIAL;
                          MAKESPACEFOR (DFILE,33);
                          WRITE (DFILE,'UNDIAGNOSABLE TAGLESS VARIANT ...');
                          END;
$
TS/PROCEDURE DETERMINEFILEATTRIBUTES;/ TS/CONST/ PS/FUNCTION/
TS/GENERATION:/ TS/LINESTART/ D/+1/
TS/ATHEADOFPAGE/ A/(// P.E I/ORD(FIBWORD(PAGEFLAGOFFSET)) = ORD(TRUE));/
T/%ENTRY/ A/%/KEYED/
T/PROCEDURE P79GETLINENO/ *2(TC/P79/, R/P79GETLINENO/ICL9LPPMLINENO/, T+1)
T/PROCEDURE P79GETROUTINEID/
*2(TC/P79/,R/P79GETROUTINEID/ICL9LPPMBLOCKID/,T+1)
T/PROCEDURE P79DUMPNAMESPACE/ R/P79DUMPNAMESPACE/ICL9LPPMDMPSPACE/
TS/FRAMEBASE/ D/ (*/ D/*)/
TC/P79/ R/P79DUMPNAMESPACE/ICL9LPPMDMPSPACE/ TS/(*/ P+1 TS/*)/ P+1
TS/HEAPORIGIN/ P+1 TC/P79/ R/P79DUMPNAMESPACE/ICL9LPPMDMPSPACE/
T/PROCEDURE P79DUMPGLOBALSPACE/ R/P79DUMPGLOBALSPACE/ICL9LPPMDMPGLOB/
TS/GLOBALBASE/ D/ (*/ D/*)/ T+1 A/TEXT/;/ T+1 R/(*;/   / D/*)/
TS/(*/ P+1 TS/*)/ P+1 TS/ARRAYSIZE/ P+1
TC/P79/ R/P79DUMPGLOBALSPACE/ICL9LPPMDMPGLOB/ T+1
PS/END (* P79FLOWANALYSISREPORT/ P+2
TELE