$CONTROL MAP,CODE,USLINIT                                               00010000
<<RINS - MODULE 73>>                                                    00012000
<< HP32002C MPE SOURCE C.00.00 >>                                       00014000
$COPYRIGHT     "(C) COPYRIGHT HEWLETT-PACKARD CO. 1980. ",            & 00016000
$     "THIS PROGRAM MAY BE USED WITH ONE COMPUTER SYSTEM AT A ",      & 00018000
$     "TIME AND SHALL NOT OTHERWISE BE RECORDED, TRANSMITTED OR ",    & 00020000
$     "STORED IN A RETRIEVAL SYSTEM.  COPYING OR OTHER REPRODUCTION ",& 00022000
$     "OF THIS PROGRAM EXCEPT FOR ARCHIVAL PURPOSES IS PROHIBITED ",  & 00024000
$     "WITHOUT THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY."   00026000
$CONTROL SEGMENT=RINS                                                   00028000
$THIRTY                                                                 00030000
<<  R I N   I N T R I N S I C S    F I L E S >>                         00032000
                                                                        00034000
                                                                        00036000
BEGIN                                                                   00038000
DEFINE DISABLE=ASSEMBLE(SED 0)#,ENABLE=ASSEMBLE(SED 1)#;                00040000
DEFINE TRAPSOFF = PUSH(STATUS); TOS.(2:1):=0; SET(STATUS)#;    <<00804>>00042000
DEFINE FORCESTKO = ASSEMBLE (ADDS 128; SUBS 128)#;             <<00804>>00044000
$INCLUDE RINSINCL                                              <<01603>>00046000
                                                                        00048000
$INCLUDE INCLMEAS                                              <<01814>>00050000
$INCLUDE INCLMIFT                                              <<04541>>00052000
$PAGE "  "                                                     <<01622>>00054000
<<------------------------------------------------------------------->> 00056000
DOUBLE PROCEDURE CHEK(INT,FL,PARM,CAPM,OVM);                            00058000
VALUE INT,FL,PARM,CAPM,OVM;                                             00060000
LOGICAL INT,FL,OVM; DOUBLE PARM,CAPM;                                   00062000
OPTION EXTERNAL,VARIABLE;                                               00064000
<<------------------------------------------------------------------->> 00066000
PROCEDURE WAIT(WF,JPCNTX);VALUE WF,JPCNTX;INTEGER WF,JPCNTX;            00068000
OPTION EXTERNAL;                                                        00070000
<<------------------------------------------------------------------->> 00072000
PROCEDURE AWAKE(PCBPT,N,W);VALUE PCBPT,N,W;INTEGER PCBPT,N,W;           00074000
OPTION EXTERNAL;                                                        00076000
<<------------------------------------------------------------------->> 00078000
LOGICAL PROCEDURE EXCHANGEDB(N);VALUE N;LOGICAL N;OPTION EXTERNAL;      00080000
<<------------------------------------------------------------------->> 00082000
LOGICAL PROCEDURE GETSIR(N);VALUE N;INTEGER N;OPTION EXTERNAL;          00084000
<<------------------------------------------------------------------->> 00086000
PROCEDURE RELSIR(N,S);VALUE N,S;INTEGER N;LOGICAL S;OPTION EXTERNAL;    00088000
<<------------------------------------------------------------------->> 00090000
PROCEDURE ERROREXIT(INT,ERB,PAR);VALUE INT,ERB,PAR;                     00092000
LOGICAL INT,ERB,PAR;OPTION EXTERNAL;                                    00094000
<<------------------------------------------------------------------->> 00096000
PROCEDURE ERRORON;OPTION EXTERNAL;                                      00098000
<<------------------------------------------------------------------->> 00100000
PROCEDURE SUDDENDEATH(N);VALUE N;INTEGER N;OPTION EXTERNAL;             00102000
<<------------------------------------------------------------------->> 00104000
PROCEDURE HELP; OPTION EXTERNAL;                                        00106000
<<------------------------------------------------------------------->> 00108000
INTEGER PROCEDURE FATHER;   OPTION EXTERNAL;                   <<00452>>00110000
<<------------------------------------------------------------------->> 00112000
PROCEDURE WRITEDSEG (DSTENTRYNUMBER);                          <<04642>>00114000
VALUE DSTENTRYNUMBER;                                          <<04642>>00116000
INTEGER DSTENTRYNUMBER;                                        <<04642>>00118000
OPTION EXTERNAL;                                               <<04642>>00120000
<<----------------------------------------------------------->><<04642>>00122000
                                                                        00124000
                                                                        00126000
                                                                        00128000
                                                                        00130000
LOGICAL PROCEDURE MRCAPOK (SIT, RINX);                         <<01603>>00132000
  VALUE SIT, RINX;   LOGICAL SIT;                              <<01603>>00134000
  INTEGER RINX;                                                <<01603>>00136000
  OPTION UNCALLABLE, PRIVILEGED, VARIABLE;                     <<00560>>00138000
                                                                        00140000
COMMENT:                                                                00142000
      1  CHECKS CALLER'S MULTIPLE RIN CAPABILITY. IF MR THEN            00144000
        RETURNS, AND MRCAPOK=TRUE                                       00146000
      2  IF SIT=TRUE THEN TEST GLOBAL RIN FLAG AND SETS IT. IF          00148000
         ALREADY SET THEN RETURNS FALSE OTHERWISE TRUE.                 00150000
      3  IF SET=FALSE THEN RESETS GLOBAL RIN FLAG IN JPCNT.             00152000
      ;                                                                 00154000
<< PARAMETER RIN ADDED TO ALLOW MRCAPOK TO RETURN TRUE    >>   <<00560>>00156000
<< WHEN PROCESS WITHOUT MR CAPABILITY TRIES TO LOCK RIN   >>   <<00560>>00158000
<< THAT IT ALREADY HAS LOCKED.                            >>   <<00560>>00160000
                                                                        00162000
BEGIN                                                                   00164000
      EQUATE ACCX=5;                                                    00166000
                                                                        00168000
      EQUATE CPCB = 4,  PCBB = 3,  PCBSIZE = 16;               <<00560>>00170000
      EQUATE RINDST = 22,  RINSIR = 38;                        <<00560>>00172000
      DEFINE PINOFLOCKER = (8:8)#;                             <<00560>>00174000
      INTEGER OVMASK = Q-4;                                    <<00560>>00176000
      DEFINE RINNOTTHERE = OVMASK.(15:1) = 0#;                 <<01918>>00178000
      INTEGER DB, SIRCOND, RIN'ENTRY, PIN;                     <<00560>>00180000
      INTEGER ARRAY PCBX(*)=Q+0;                                        00182000
      INTEGER X=X;                                                      00184000
      INTEGER JPCNTX;                                                   00186000
      INTEGER RINPTR;                                          <<01603>>00188000
      POINTER  JPCNT = %15;                                             00190000
                                                                        00192000
                                                                        00194000
      PUSH(DL,Q);ASSEMBLE(XCH,SUB;DUP,STAX;DECX,DECX);                  00196000
      TOS:=-PCBX(X); ASSEMBLE(ADD);TOS:=TOS+ACCX;                       00198000
      ASSEMBLE(STAX);TOS:=PCBX(X);                                      00200000
      IF TOS&LSR(3)  THEN              <<TEST FOR MR CAP>>              00202000
      BEGIN                            <<MR CAP>>                       00204000
         MRCAPOK:=TRUE;                                                 00206000
         RETURN;                                                        00208000
      END;                                                              00210000
                                                                        00212000
      RINPTR := RINX*RIN'LENGTH;                               <<01603>>00214000
      JPCNTX:=PCBX(X-9)&LSR(8);        <<JOB PROCESS COUNT INDEX>>      00216000
      TOS := (JPCNT(0).(0:8)+3)&LSR(1);                                 00218000
      TOS:=JPCNTX;                                                      00220000
      TOS:=0;                                                           00222000
      ASSEMBLE(DLSR 4);                <<DIVIDE BY 16>>                 00224000
      TOS:=TOS&LSR(12);                <<FORMAT REMAINDER>>             00226000
      ASSEMBLE(XCH,CAB;ADD,STAX);                                       00228000
      SIRCOND := GETSIR (RINSIR);                              <<00560>>00230000
      TOS := JPCNT(X);                                                  00232000
      TOS:=X;                                                           00234000
      ASSEMBLE(XCH,CAB;STAX);                                           00236000
                                                                        00238000
      IF SIT THEN                      <<TEST AND SET BIT>>             00240000
      BEGIN                                                             00242000
         ASSEMBLE(TSBC 0,X);           <<TEST GLOB RIN FLAG>>           00244000
         IF <> THEN                    <<NOT 0 = AN ERROR?>>   <<00560>>00246000
         BEGIN                                                 <<00560>>00248000
           IF RINNOTTHERE THEN                                 <<00560>>00250000
             MRCAPOK := FALSE                                  <<00560>>00252000
           ELSE                                                <<00560>>00254000
             BEGIN                                             <<00560>>00256000
               PIN := (ABSOLUTE(CPCB)-ABSOLUTE(PCBB))/PCBSIZE; <<00560>>00258000
               DB := EXCHANGEDB (RINDST);                      <<00560>>00260000
                IF RIN'E'HOLDER = PIN THEN                     <<01603>>00262000
                  MRCAPOK := TRUE                              <<01603>>00264000
               ELSE                                            <<00560>>00266000
                 MRCAPOK := FALSE;                             <<00560>>00268000
               EXCHANGEDB (DB);                                <<00560>>00270000
             END;                                              <<00560>>00272000
         END                                                   <<00560>>00274000
         ELSE                                                           00276000
         BEGIN                         <<BIT NOT SET = OK>>             00278000
M1:         ASSEMBLE(XCH,STAX);                                         00280000
            JPCNT(X):=TOS;                                              00282000
            MRCAPOK := TRUE;                                            00284000
         END                                                            00286000
      END ELSE                                                          00288000
      BEGIN                            <<RESET THE BIT>>                00290000
         ASSEMBLE(TRBC 0,X);                                            00292000
         GOTO M1;                                                       00294000
         HELP;  << DUMMY CALL FOR DEBUGGING LINK >>                     00296000
      END;                                                              00298000
                                                               <<00560>>00300000
      RELSIR (RINSIR, SIRCOND);                                <<00560>>00302000
                                                                        00304000
END;     <<  M R C A P O K  >>                                          00306000
<<------------------------------------------------------------------->> 00308000
                                                                        00310000
                                                                        00312000
                                                                        00314000
                                                                        00316000
PROCEDURE RLOCK(RINX,UNCOND);                                  <<01603>>00318000
VALUE RINX,UNCOND;                                             <<01603>>00320000
INTEGER RINX;                                                  <<01603>>00322000
LOGICAL UNCOND;                                                         00324000
OPTION UNCALLABLE,PRIVILEGED;                                           00326000
                                                                        00328000
                                                                        00330000
COMMENT: LOCKS THE SPECIFIED RIN.                                       00332000
         IF UNCOND=TRUE THEN UNCONDITIONALLY                            00334000
         IF UNCOND=FALSE THEN ONLY IF NOT LOCKED                        00336000
                                                                        00338000
      RETURNS                                                           00340000
         CCE   GRANTED                                                  00342000
         CCG   GRANTED BUT THE PROCESS ALREADY HAD IT                   00344000
         CCL   (ONLY IF UNCOND=FALSE) NOT GRANTED BECAUSE LOCKED        00346000
         CCX   NOT ALLOCATED                                            00348000
                                                                        00350000
      IF BIT 0 OF "RINX" IS 1 THEN DB IS AREADY POINTING TO RIN TABLE   00352000
      ;                                                                 00354000
                                                                        00356000
                                                                        00358000
                                                                        00360000
BEGIN                                                                   00362000
      EQUATE CCG=0,CCL=1,CCE=2,CCX=3;                                   00364000
      EQUATE RINDST=22,RINSIR=38;                                       00366000
      EQUATE CPCB=4,PCBB=3,PCBSIZE=16;                                  00368000
      INTEGER POINTER  PCB = 3;                                         00370000
                                                                        00372000
      ARRAY RINSEG(*)=DB+0;                                             00374000
      INTEGER X=X,PIN,DB,SIRF,CC,PINX;                                  00376000
      LOGICAL DBF:=FALSE;                                               00378000
      INTEGER STATUS=Q-1,WAITF;                                         00380000
      INTEGER RINPTR;                                          <<01603>>00382000
                                                                        00384000
                                                                        00386000
                                                                        00388000
      PIN:=(PINX := ABSOLUTE(CPCB)-ABSOLUTE(PCBB))/PCBSIZE;             00390000
                                                                        00392000
      IF RINX<0 THEN RINX.(0:1) := 0 ELSE                      <<01603>>00394000
      BEGIN                                                             00396000
         DBF:=TRUE;                                                     00398000
         DB:=EXCHANGEDB(RINDST);       <<DB POINTS TO RIN TABLE>>       00400000
      END;                                                              00402000
                                                                        00404000
      SIRF:=GETSIR(RINSIR);            <<LOCK RIN>>                     00406000
                                                                        00408000
      RINPTR := RINX*RIN'LENGTH;                               <<01603>>00410000
      IF RIN'E'TYPE = 0 THEN                                   <<01603>>00412000
      BEGIN                               << NOT ALLOCATED >>  <<01603>>00414000
        RELSIR(RINSIR,SIRF);                                   <<01603>>00416000
        IF DBF THEN EXCHANGEDB(DB);                            <<01603>>00418000
        STATUS.(6:2) := CCX;                                   <<01603>>00420000
        RETURN;                                                <<01603>>00422000
      END;                                                     <<01603>>00424000
      IF RIN'E'TYPE = 1 THEN WAITF := %1000                    <<01603>>00426000
      ELSE WAITF := %2000;                                     <<01603>>00428000
      IF RIN'E'HOLDER = PIN THEN                               <<01603>>00430000
      BEGIN              << THE PROCESS ALREADY HAS IT >>      <<01603>>00432000
        RELSIR(RINSIR,SIRF);                                   <<01603>>00434000
        IF DBF THEN EXCHANGEDB(DB);                            <<01603>>00436000
        STATUS.(6:2) := CCG;                                   <<01603>>00438000
        RETURN;                                                <<01603>>00440000
      END;                                                     <<01603>>00442000
      IF RIN'E'HOLDER = 0 THEN                                 <<01603>>00444000
      BEGIN  << RIN FREE >>                                    <<01603>>00446000
        RIN'E'HOLDER := PIN;                                   <<01603>>00448000
        RELSIR(RINSIR,SIRF);  << UNBLOCK RIN >>                <<01603>>00450000
        IF DBF THEN EXCHANGEDB(DB);                            <<01603>>00452000
        STATUS.(6:2) := CCE;                                   <<01603>>00454000
        RETURN;                                                <<01603>>00456000
      END;                                                     <<01603>>00458000
                                                                        00460000
      <<AT THIS POINT THE RIN IS LOCKED BY ANOTHER PROCESS>>            00462000
                                                                        00464000
      IF NOT(UNCOND) THEN              <<THE RIN ASKED CONDITIONALLY>>  00466000
      BEGIN                                                             00468000
          RELSIR(RINSIR,SIRF);                                 <<01603>>00470000
          IF DBF THEN EXCHANGEDB(DB);                          <<01603>>00472000
          STATUS.(6:2) := CCL;                                 <<01603>>00474000
          RETURN;                                              <<01603>>00476000
      END;                                                              00478000
                                                                        00480000
      PCB(PINX+8).(8:8) := 0;                                           00482000
      IF RIN'E'HEADQ = 0 THEN  << NO PROCESS WAITING >>        <<01603>>00484000
        RIN'E'HEADQ := PIN                                     <<01603>>00486000
      ELSE  << PUT AT END OF LIST >>                           <<01603>>00488000
      BEGIN                                                             00490000
          TOS := RIN'E'HEADQ;                                  <<01603>>00492000
         WHILE  PCB(TOS*PCBSIZE+8).(8:8) <> 0  DO                       00494000
                TOS := PCB(X).(8:8);                                    00496000
         PCB(X).(8:8) := PIN;                                           00498000
      END;                                                              00500000
                                                                        00502000
      <<PROCESS GOES TO WAIT>>                                          00504000
      ASSEMBLE( PSDB );                                                 00506000
      RELSIR(RINSIR,SIRF.(15:1));      <<RELEASE RIN SIR>>              00508000
      IF GCLASSENABLEDMASK.CLASS15 THEN                        <<01814>>00510000
         BEGIN <<PROCESS LEVEL RIN WAIT>>                      <<01814>>00512000
         TOS:=MEASPROCXDSBANK;                                 <<01814>>00514000
         TOS:=MEASPROCXDSBASE+LOGICAL(PIN)*CLASS15'SUB0SIZE+   <<01814>>00516000
              CP'STOPRIN;                                      <<01814>>00518000
         ASSEMBLE(LSEA;INCA;SSEA;DDEL);                        <<01814>>00520000
         END;                                                  <<01814>>00522000
      WAIT(WAITF,0);                                                    00524000
                                                                        00526000
                                                                        00528000
      IF DBF THEN EXCHANGEDB(DB);                              <<01603>>00530000
      STATUS.(6:2) := CCE;                                     <<01603>>00532000
                                                                        00534000
END;  << R L O C K  >>                                                  00536000
                                                                        00538000
<<------------------------------------------------------------------->> 00540000
                                                                        00542000
                                                                        00544000
                                                                        00546000
                                                                        00548000
                                                                        00550000
                                                                        00552000
PROCEDURE RUNLOCK(RINX);                                       <<01603>>00554000
VALUE RINX;                                                    <<01603>>00556000
INTEGER RINX;                                                  <<01603>>00558000
OPTION UNCALLABLE,PRIVILEGED;                                           00560000
                                                                        00562000
COMMENT: UNLOCKS THE SPECIFIED RIN.                                     00564000
         IF RINX.(0:1)=1 THEN DB ALREADY POINTING TO RIN TABLE.<<01603>>00566000
                                                                        00568000
      RETURNS                                                           00570000
         CCE   GRANTED                                                  00572000
         CCG   IF PROCESS HAD NOT THE RIN                               00574000
         CCL   IF RIN NOT ALLOCATED                                     00576000
                                                                        00578000
      ;                                                                 00580000
                                                                        00582000
BEGIN                                                                   00584000
      EQUATE CCG=0,CCL=1,CCE=2;                                         00586000
      EQUATE RINDST=22,RINSIR=38;                                       00588000
      EQUATE CPCB=4,PCBB=3,PCBSIZE=16;                                  00590000
                                                                        00592000
                                                                        00594000
      INTEGER X=X,PCBT,CC,PIN,NEXT:=0,STATUS=Q-1,SIRF,D;                00596000
      INTEGER DB;                                                       00598000
      LOGICAL DBF:=FALSE,AF:=FALSE,GR:=FALSE,LR:=FALSE,SR:=FALSE;       00600000
      INTEGER AWF;                                                      00602000
      INTEGER RINPTR;                                          <<01603>>00604000
ENTRY GRUNLOCK,LRUNLOCK;                                                00606000
      SR:=TRUE;                                                         00608000
      GO ALL;                                                           00610000
GRUNLOCK:  GR:=TRUE;                                                    00612000
           GO ALL;                                                      00614000
LRUNLOCK:  LR:=TRUE;                                                    00616000
ALL:                                                                    00618000
      PCBT:=ABSOLUTE(PCBB);                                             00620000
      PIN:=(ABSOLUTE(CPCB)-PCBT)/PCBSIZE;                               00622000
                                                                        00624000
      IF RINX<0 THEN RINX.(0:1):=0 ELSE                        <<01603>>00626000
      BEGIN                                                             00628000
         DBF:=TRUE;                                                     00630000
         DB:=EXCHANGEDB(RINDST);                                        00632000
      END;                                                              00634000
      SIRF:=GETSIR(RINSIR);                                             00636000
      RINPTR := RINX*RIN'LENGTH;                               <<01603>>00638000
      IF NOT SR THEN                                           <<01603>>00640000
      BEGIN                                                    <<01603>>00642000
        IF RIN'TOTALNUM/RIN'LENGTH < RINX THEN                 <<01603>>00644000
        BEGIN               << INVALID RIN # >>                <<01603>>00646000
          RELSIR(RINSIR,SIRF);                                 <<01603>>00648000
          IF DBF THEN EXCHANGEDB(DB);                          <<01603>>00650000
          STATUS.(6:2) := CCL;                                 <<01603>>00652000
          RETURN;                                              <<01603>>00654000
        END;                                                   <<01603>>00656000
        IF GR AND RIN'E'TYPE <> 2 OR                           <<01603>>00658000
           LR AND RIN'E'TYPE <> 1 THEN                         <<01603>>00660000
        BEGIN                                                  <<01603>>00662000
          RELSIR(RINSIR,SIRF);                                 <<01603>>00664000
          IF DBF THEN EXCHANGEDB(DB);                          <<01603>>00666000
          STATUS.(6:2) := CCL;                                 <<01603>>00668000
          RETURN;                                              <<01603>>00670000
        END;                                                   <<01603>>00672000
      END;                                                     <<01603>>00674000
      IF RIN'E'TYPE = 1 THEN AWF := %1000                      <<01603>>00676000
      ELSE AWF := %2000;                                       <<01603>>00678000
      IF RIN'E'HOLDER = PIN THEN                               <<01603>>00680000
      BEGIN                   << THE PROCESS HAS THE RIN >>    <<01603>>00682000
        NEXT := RIN'E'HEADQ;                                   <<01603>>00684000
        RIN'E'HOLDER := RIN'E'HEADQ;                           <<01603>>00686000
        IF RIN'E'HEADQ <> 0 THEN RIN'E'HEADQ :=                <<01603>>00688000
           ABSOLUTE(PCBT+RIN'E'HEADQ*PCBSIZE+8).(8:8);         <<01603>>00690000
        CC := CCE                                              <<01603>>00692000
      END                                                      <<01603>>00694000
      ELSE              << CALLER DOES NOT HAVE THE RIN >>     <<01603>>00696000
        IF RIN'E'TYPE = 0 THEN CC := CCL                       <<01603>>00698000
        ELSE CC := CCG;                                        <<01603>>00700000
      RELSIR(RINSIR,SIRF);                                     <<01603>>00702000
      IF NEXT <> 0 THEN AWAKE(NEXT*PCBSIZE,AWF,0);             <<01603>>00704000
      IF DBF THEN EXCHANGEDB(DB);                              <<01603>>00706000
      STATUS.(6:2) := CC;            <<SET CC >>               <<01603>>00708000
                                                                        00710000
END;  << R U N L O C K  >>                                              00712000
                                                               <<04642>>00714000
<<------------------------------------------------------------------->> 00716000
                                                                        00718000
                                                                        00720000
                                                                        00722000
                                                                        00724000
                                                                        00726000
                                                                        00728000
INTEGER PROCEDURE ALLORIN(RCODE,USNAM,PASSW);                           00730000
VALUE RCODE;                                                            00732000
INTEGER RCODE;                                                          00734000
ARRAY USNAM,PASSW;                                                      00736000
OPTION UNCALLABLE,PRIVILEGED,VARIABLE;                                  00738000
                                                                        00740000
                                                                        00742000
COMMENT: ALLOCATES A RIN ENTRY                                          00744000
         RCODE DEFINES THE RIN TYPE                                     00746000
            1  LOCAL RIN                                                00748000
            2  GLOBAL RIN                                               00750000
            3  FILE RIN                                                 00752000
                                                                        00754000
         RETURNS THE GLOBAL RIN NUMBER TO CALLER(0 IF NONE AVAILABLE)   00756000
                                                                        00758000
         IF RCODE.(0:1)=1 THEN DB IS ALREADY POINTING TO RIN TABLE      00760000
               ( FOR LOCAL AND FILE RIN ONLY )                          00762000
                                                                        00764000
      ;                                                                 00766000
                                                                        00768000
BEGIN                                                                   00770000
      EQUATE RINDST=22,RINSIR=38;                                       00772000
                                                                        00774000
                                                                        00776000
      INTEGER D;                                                        00778000
      LOGICAL VAR=Q-4;                                                  00780000
      ARRAY USER(0:8)=Q;                                                00782000
      ARRAY RPASS(0:4)=Q;                                               00784000
      DOUBLE ARRAY RINT(*)=DB+0;                                        00786000
      INTEGER R;                                                        00788000
      LOGICAL DBF:=FALSE;                                               00790000
      INTEGER X=X,DB,CX,SIRF,I;                                         00792000
      INTEGER RINPTR,                                          <<01603>>00794000
              RIN'PASSUSERINX;                                 <<01603>>00796000
                                                                        00798000
                                                                        00800000
      IF VAR&LSR(1) THEN               <<USNAM PARAMETER PRESENT>>      00802000
      BEGIN                            <<COPY USNAM LOCALLY>>           00804000
         CX:=-1;                                                        00806000
         WHILE (CX:=CX+1)<8  DO USER(CX):=USNAM(CX);                    00808000
      END;                                                              00810000
                                                                        00812000
      IF VAR THEN                      <<PASSW PARAMETER PRESENT>>      00814000
      BEGIN                                                             00816000
         CX:=-1;                                                        00818000
         WHILE (CX:=CX+1)<4 DO RPASS(CX):=PASSW(CX);                    00820000
      END;                                                              00822000
                                                                        00824000
      IF RCODE<0 THEN RCODE.(0:1):=0 ELSE                               00826000
      BEGIN                                                             00828000
         DBF:=TRUE;                                                     00830000
         DB:=EXCHANGEDB(RINDST);                                        00832000
      END;                                                              00834000
      SIRF:=GETSIR(RINSIR);                                             00836000
                                                                        00838000
      IF RIN'FIRSTFREE = 0 THEN                                <<01603>>00840000
      BEGIN                   << NO AVAILABLE RIN >>           <<01603>>00842000
        ALLORIN := 0;                                          <<01603>>00844000
        RELSIR(RINSIR,SIRF);                                   <<01603>>00846000
        IF DBF THEN EXCHANGEDB(DB);                            <<01603>>00848000
        RETURN;                                                <<01603>>00850000
      END;                                                     <<01603>>00852000
      IF RCODE = 2 AND RIN'FREEPTR = 0 THEN                    <<01603>>00854000
      BEGIN << NO PASS ENTRY AVAILABLE FOR GLOBAL RINS >>      <<01603>>00856000
        ALLORIN := 0;                                          <<01603>>00858000
        RELSIR(RINSIR,SIRF);                                   <<01603>>00860000
        IF DBF THEN EXCHANGEDB(DB);                            <<01603>>00862000
        RETURN;                                                <<01603>>00864000
      END;                                                     <<01603>>00866000
      RINPTR := RIN'FIRSTFREE;                                 <<01603>>00868000
      ALLORIN := RIN'FIRSTFREE/RIN'LENGTH;                     <<01603>>00870000
      RIN'FIRSTFREE := RIN'E'INDEX;    << RELINK >>            <<01603>>00872000
      RIN'E'TYPE := RCODE;                                     <<01603>>00874000
      RIN'E'INDEX := 0;                                        <<01603>>00876000
      IF RIN'E'TYPE = 2 THEN                                   <<01603>>00878000
      BEGIN                         << GLOBAL RIN >>           <<01603>>00880000
        RIN'E'INDEX := RIN'FREEPTR;                            <<01603>>00882000
        RIN'FREEPTR := RIN'E'NEXTFREE;                         <<01603>>00884000
        IF VAR THEN                << PASSWORD PRESENT >>      <<01603>>00886000
        BEGIN                                                  <<01603>>00888000
          RIN'PASSUSERINX := 0;                                <<01603>>00890000
          WHILE RIN'PASSUSERINX < 4 DO                         <<01603>>00892000
          BEGIN                                                <<01603>>00894000
            RIN'E'PASSWORD := RPASS(RIN'PASSUSERINX);          <<01603>>00896000
            RIN'PASSUSERINX := RIN'PASSUSERINX+1;              <<01603>>00898000
          END;                                                 <<01603>>00900000
        END                                                    <<01603>>00902000
        ELSE                                                   <<01603>>00904000
        BEGIN                                                  <<01603>>00906000
          RIN'PASSUSERINX := 0;                                <<01603>>00908000
          RIN'E'PASSWORD := 0;                                 <<01603>>00910000
        END;                                                   <<01603>>00912000
        RIN'PASSUSERINX := 0;                                  <<01603>>00914000
        WHILE RIN'PASSUSERINX < 8 DO                           <<01603>>00916000
        BEGIN                                                  <<01603>>00918000
          RIN'E'USERNAME := USER(RIN'PASSUSERINX);             <<01603>>00920000
          RIN'PASSUSERINX := RIN'PASSUSERINX+1;                <<01603>>00922000
        END;                                                   <<01603>>00924000
        RIN'FREENTRIES := RIN'FREENTRIES-1;                    <<01603>>00926000
               << DECREMENT FREE ENTRY COUNT >>                <<01603>>00928000
      END;                                                     <<01603>>00930000
      RIN'E'HEADQ := 0;                                        <<01603>>00932000
      RIN'E'HOLDER := 0;                                       <<01603>>00934000
      IF DBF THEN EXCHANGEDB(DB);                              <<01603>>00938000
<< IF GLOBAL RIN MAKE THE MODIFIED RIN TABLE PERMANENT>>       <<04642>>00940000
IF RCODE = 2 THEN WRITEDSEG(RINDST);                           <<04642>>00942000
RELSIR(RINSIR,SIRF);                                           <<04642>>00944000
                                                                        00946000
END;  << A L L O R I N  >>                                              00948000
<<------------------------------------------------------------------->> 00950000
                                                                        00952000
                                                                        00954000
                                                                        00956000
                                                                        00958000
                                                                        00960000
                                                                        00962000
PROCEDURE DEALLORIN(RINX,USNAM);                               <<01603>>00964000
VALUE RINX;                                                    <<01603>>00966000
INTEGER RINX;                                                  <<01603>>00968000
ARRAY USNAM;                                                            00970000
OPTION PRIVILEGED,UNCALLABLE,VARIABLE;                                  00972000
                                                                        00974000
                                                                        00976000
COMMENT: DEALLOCATES THE SPECIFIED RIN.                                 00978000
                                                                        00980000
      RETURNS                                                           00982000
                                                                        00984000
         CCE   OK                                                       00986000
         CCG   IF RIN IS CURRENTLY USED                                 00988000
         CCL   IF RIN WAS NOT ALLOCATED TO THIS USER(GLOBAL RIN)        00990000
               OR RIN > # OF CONFIGURED RINS                   <<00859>>00992000
                                                                        00994000
      "USNAM" OMITTED IF NOT A GLOBAL RIN.                              00996000
                                                                        00998000
       IF RINX.(0:1)=1 DB IS ALREADY POINTING TO RIN TABLE     <<01603>>01000000
         ( FOR LOCAL AND FILE RINS ONLY )                               01002000
      ;                                                                 01004000
                                                                        01006000
                                                                        01008000
BEGIN                                                                   01010000
      EQUATE RINDST=22,RINSIR=38;                                       01012000
      EQUATE CCG=0,CCL=1,CCE=2;                                         01014000
                                                                        01016000
      INTEGER X=X,CX,DB,SIRF,CC,I,D;                                    01018000
      INTEGER STATUS=Q-1;                                               01020000
      INTEGER RINPTR,                                          <<01603>>01022000
              RIN'PASSUSERINX;                                 <<01603>>01024000
      LOGICAL VAR=Q-4;                                         <<04769>>01026000
      LOGICAL DBF:=FALSE;                                      <<04769>>01028000
      LOGICAL GLOBALRIN:=FALSE;                                <<04769>>01030000
      ARRAY USER(0:8)=Q;                                                01032000
                                                                        01034000
                                                                        01036000
      IF VAR THEN                                                       01038000
      BEGIN                                                             01040000
         CX:=-1;                                                        01042000
         WHILE (CX:=CX+1)<8 DO USER(CX):=USNAM(CX);                     01044000
      END;                                                              01046000
                                                                        01048000
      IF RINX<0 THEN RINX.(0:1):= 0 ELSE                       <<01603>>01050000
      BEGIN                                                             01052000
         DBF:=TRUE;                                                     01054000
         DB:=EXCHANGEDB(RINDST);                                        01056000
      END;                                                              01058000
                                                                        01060000
      SIRF:=GETSIR(RINSIR);                                             01062000
                                                                        01064000
      RINPTR := RINX*RIN'LENGTH;                               <<01603>>01066000
      IF RINX > (RIN'TOTALNUM/RIN'LENGTH)-1 THEN               <<01603>>01068000
      BEGIN               << THE RIN IS BEYOND RINTABLE >>     <<01603>>01070000
        RELSIR(RINSIR,SIRF);                                   <<01603>>01072000
        IF DBF THEN EXCHANGEDB(DB);                            <<01603>>01074000
        STATUS.(6:2) := CCL;                                   <<01603>>01076000
        RETURN;                                                <<01603>>01078000
      END;                                                     <<01603>>01080000
      IF RIN'E'HOLDER <> 0 THEN                                <<01603>>01082000
      BEGIN               << THE RIN IS CURRENTLY LOCKED >>    <<01603>>01084000
        RELSIR(RINSIR,SIRF);                                   <<01603>>01086000
        IF DBF THEN EXCHANGEDB(DB);                            <<01603>>01088000
        STATUS.(6:2) := CCG;                                   <<01603>>01090000
        RETURN;                                                <<01603>>01092000
      END;                                                     <<01603>>01094000
      IF RIN'E'TYPE = 0 THEN                                   <<01603>>01096000
      BEGIN               << NOT ALLOCATED >>                  <<01603>>01098000
        RELSIR(RINSIR,SIRF);                                   <<01603>>01100000
        IF DBF THEN EXCHANGEDB(DB);                            <<01603>>01102000
        STATUS.(6:2) := CCL;                                   <<01603>>01104000
        RETURN;                                                <<01603>>01106000
      END;                                                     <<01603>>01108000
      IF RIN'E'TYPE = 2 THEN                                   <<01603>>01110000
      BEGIN               << GLOBAL RIN >>                     <<01603>>01112000
        GLOBALRIN:=TRUE;                                       <<04642>>01114000
        RIN'PASSUSERINX := 0;                                  <<01603>>01116000
        WHILE RIN'PASSUSERINX < 8 DO                           <<01603>>01118000
        BEGIN                                                  <<01603>>01120000
          IF LOGICAL(RIN'E'USERNAME) <> USER(RIN'PASSUSERINX)  <<01603>>01122000
          THEN                     << NOT GRANTED >>           <<01603>>01124000
          BEGIN                                                <<01603>>01126000
            RELSIR(RINSIR,SIRF);                               <<01603>>01128000
            IF DBF THEN EXCHANGEDB(DB);                        <<01603>>01130000
            STATUS.(6:2) := CCL;                               <<01603>>01132000
            RETURN;                                            <<01603>>01134000
          END;                                                 <<01603>>01136000
          RIN'PASSUSERINX := RIN'PASSUSERINX+1;                <<01603>>01138000
        END;                                                   <<01603>>01140000
        RIN'E'LINK := RIN'FREEPTR;  << RELINK >>               <<01603>>01142000
        RIN'FREEPTR := RIN'E'INDEX;                            <<01603>>01144000
        RIN'FREENTRIES := RIN'FREENTRIES+1;                    <<01603>>01146000
      END                                                      <<01603>>01148000
      ELSE                                                     <<01603>>01150000
       IF VAR THEN                                             <<01603>>01152000
        BEGIN                                                  <<01603>>01154000
         RELSIR(RINSIR,SIRF);                                  <<01603>>01156000
         IF DBF THEN EXCHANGEDB(DB);                           <<01603>>01158000
         STATUS.(6:2) := CCL;                                  <<01603>>01160000
         RETURN;                                               <<01603>>01162000
        END;                                                   <<01603>>01164000
      RIN'E'TYPE := 0;                                         <<01603>>01166000
      RIN'E'INDEX := RIN'FIRSTFREE;                            <<01603>>01168000
      RIN'E'HEADQ := 0;                                        <<01603>>01170000
      RIN'E'HOLDER := 0;                                       <<01603>>01172000
      RIN'FIRSTFREE := RINPTR;                                 <<01603>>01174000
      IF DBF THEN EXCHANGEDB(DB);                              <<01603>>01178000
      IF GLOBALRIN THEN WRITEDSEG(RINDST); <<RIN DST TO DISC>> <<04642>>01180000
      RELSIR(RINSIR,SIRF);                                     <<04642>>01182000
      STATUS.(6:2) := CCE;                                     <<01603>>01184000
                                                                        01186000
END;  << D E A L L O R I N  >>                                          01188000
<<------------------------------------------------------------------->> 01190000
                                                                        01192000
                                                                        01194000
                                                                        01196000
                                                                        01198000
                                                                        01200000
PROCEDURE LOCKGLORIN(RINX,UNCOND,RINPASSW);                    <<01603>>01202000
VALUE RINX;                                                    <<01603>>01204000
INTEGER RINX;                                                  <<01603>>01206000
LOGICAL UNCOND;                                                         01208000
BYTE ARRAY RINPASSW;                                                    01210000
OPTION PRIVILEGED;                                                      01212000
                                                                        01214000
                                                                        01216000
COMMENT: LOCKS THE GLOBAL RIN SPECIFIED.                                01218000
                                                                        01220000
         RETURNS (IF UNCOND=TRUE)                                       01222000
            CCE   GRANTED(UNCOND CHANGED TO FALSE IF RIN FREE)          01224000
            CCG   (NULL)                                                01226000
            CCL   INVALID RIN (NOT ALLOCATED, NOT A GLOBAL     <<00452>>01228000
                               RIN, EXCEEDS RIN TABLE, OR      <<00452>>01230000
                               INCORRECT PASSWORD)             <<00452>>01232000
                                                                        01234000
         RETURNS (IF UNCOND=FALSE)                                      01236000
            CCE   GRANTED:UNCOND CHANGED TO TRUE IF RIN LOCKED BY CALLER01238000
            CCG   RIN WAS LOCKED BY ANOTHER PROCESS                     01240000
            CCL   (SAME AS ABOVE)                                       01242000
                                                                        01244000
         ERRORS                                                         01246000
           21  UNDER CLASS 0 OR 1 ONLY ONE RIN CAN BE LOCKED            01248000
               AT ANY ONE TIME                                          01250000
                                                                        01252000
      ;                                                                 01254000
                                                                        01256000
BEGIN                                                                   01258000
      EQUATE RINDST=22,RINSIR=38;                                       01260000
      EQUATE CCG=0,CCL=1,CCE=2;                                         01262000
      EQUATE ACCX=5;                                                    01264000
                                                                        01266000
      INTEGER INT,ERR:=0;                                               01268000
      INTEGER X=X;                                                      01270000
      INTEGER STATUS=Q-1;                                               01272000
      INTEGER ARRAY PCBX(*)=Q+0;                                        01274000
      BYTE ARRAY JPCNT(*)=DB+0;                                         01276000
      BYTE ARRAY RPASS(0:8)=Q;                                          01278000
      ARRAY WRPASS(*)=RPASS;                                            01280000
      INTEGER JPCNTX,DB,SIRF,CX,I,CC,CC';                               01282000
      INTEGER ARRAY JGLOF(*)=DB+0;                                      01284000
      INTEGER RINPTR,                                          <<01603>>01286000
              RIN'PASSUSERINX;                                 <<01603>>01288000
                                                                        01290000
                                                                        01292000
      ERRORON;                                                          01294000
      RINPTR := RINX*RIN'LENGTH;                               <<01603>>01296000
      INT:=34&LSL(6)+3;                                                 01298000
      CHEK(INT,3,%70D);                                        <<00099>>01300000
      << Get password and check its length: >>                 <<01928>>01302000
      MOVE RPASS := RINPASSW, (8);                             <<01928>>01304000
      RPASS(8):=" "; << STOP CHARACTER >>                      <<01928>>01306000
      MOVE RPASS := RPASS WHILE ANS, 1; << SCAN FOR LENGTH >>  <<01928>>01308000
      I := TOS - @RPASS;  << STORE LENGTH IN I >>              <<01928>>01310000
     IF I=8 AND (RINPASSW(8)=ALPHA OR RINPASSW(8)=NUMERIC) THEN<<01928>>01312000
                                                               <<01942>>01314000
         BEGIN                                                 <<01928>>01316000
         STATUS.(6:2) := CCL;                                  <<01928>>01318000
         ERROREXIT (INT,ERR,0);                                <<01928>>01320000
         RETURN;                                               <<01928>>01322000
         END;                                                  <<01928>>01324000
      RPASS (I) := " ";  << BLANK OUT REST OF ARRAY: >>        <<01928>>01326000
      IF I < 7 THEN                                            <<01928>>01328000
         MOVE RPASS(I+1):=RPASS(I),(7-I);                      <<01928>>01330000
                                                                        01332000
      IF NOT MRCAPOK (TRUE, RINX) THEN    << ERROR >>          <<01603>>01334000
      BEGIN                                                             01336000
         ERR:=21;                      <<ERROR ABORT #21>>              01338000
         ERROREXIT(INT,ERR,0);                                 <<01603>>01340000
         RETURN;                                               <<01603>>01342000
      END;                                                              01344000
                                                                        01346000
      DB:=EXCHANGEDB(RINDST);          <<DB TO RIN TABLE>>              01348000
      SIRF:=GETSIR(RINSIR);                                             01350000
      IF RINX > RIN'TOTALNUM THEN                              <<01603>>01352000
      BEGIN  << RIN EXCEEDS THE TABLE SIZE >>                  <<01603>>01354000
        MRCAPOK (FALSE);                                       <<01603>>01356000
        STATUS.(6:2) := CCL;                                   <<01603>>01358000
        RELSIR(RINSIR,SIRF);  <<RELEASE RIN >>                 <<01603>>01360000
        EXCHANGEDB(DB);                                        <<01603>>01362000
        ERROREXIT(INT,ERR,0);                                  <<01603>>01364000
        RETURN;                                                <<01603>>01366000
      END;                                                     <<01603>>01368000
      IF RIN'E'TYPE <> 2 THEN                                  <<01603>>01370000
      BEGIN  << NOT A GLOBAL RIN >>                            <<01603>>01372000
        MRCAPOK (FALSE);                                       <<01603>>01374000
        STATUS.(6:2) := CCL;                                   <<01603>>01376000
        RELSIR(RINSIR,SIRF);  <<RELEASE RIN >>                 <<01603>>01378000
        EXCHANGEDB(DB);                                        <<01603>>01380000
        ERROREXIT(INT,ERR,0);                                  <<01603>>01382000
        RETURN;                                                <<01603>>01384000
      END;                                                     <<01603>>01386000
      RIN'PASSUSERINX := -1;                                   <<01928>>01388000
      WHILE (RIN'PASSUSERINX:=RIN'PASSUSERINX+1)<=3 DO         <<01928>>01390000
        IF LOGICAL(RIN'E'PASSWORD) <> WRPASS(RIN'PASSUSERINX)  <<01603>>01392000
        THEN                                                   <<01603>>01394000
        BEGIN  << INCORRECT RIN PASSWORD >>                    <<01603>>01396000
          MRCAPOK (FALSE);                                     <<01603>>01398000
          STATUS.(6:2) := CCL;                                 <<01603>>01400000
          RELSIR(RINSIR,SIRF);  <<RELEASE RIN >>               <<01603>>01402000
          EXCHANGEDB(DB);                                      <<01603>>01404000
          ERROREXIT(INT,ERR,0);                                <<01603>>01406000
          RETURN;                                              <<01603>>01408000
        END;                                                   <<01603>>01410000
        EXCHANGEDB(DB);  << TO STACK >>                        <<01603>>01412000
        RLOCK(RINX,UNCOND);  << LOCKS THE RIN >>               <<01603>>01414000
          PUSH(STATUS);                                        <<01603>>01416000
          CC' := TOS.(6:2);                                    <<01603>>01418000
          CASE CC' OF                                          <<01603>>01420000
      BEGIN                                                             01422000
         BEGIN CC:=CCE;UNCOND:=FALSE;END;                               01424000
         BEGIN MRCAPOK(FALSE);CC:=CCG;END;                              01426000
         BEGIN CC:=CCE;UNCOND:=TRUE;END;                                01428000
         BEGIN CC:=CCL; END;                                   <<00452>>01430000
      END;                                                              01432000
                                                                        01434000
      IF CC = CCL THEN MRCAPOK (FALSE);                        <<01603>>01436000
      STATUS.(6:2) := CC;                                      <<00452>>01438000
      RELSIR (RINSIR, SIRF);                                   <<00452>>01440000
      EXCHANGEDB(DB);                                                   01442000
      ERROREXIT(INT,ERR,0);                                    <<01603>>01444000
                                                                        01446000
END;  << L O C K G L O R I N  >>                                        01448000
<<------------------------------------------------------------------->> 01450000
                                                                        01452000
                                                                        01454000
                                                                        01456000
                                                                        01458000
                                                                        01460000
                                                                        01462000
PROCEDURE UNLOCKGLORIN(RINX);                                  <<01603>>01464000
VALUE RINX;                                                    <<01603>>01466000
INTEGER RINX;                                                  <<01603>>01468000
OPTION PRIVILEGED;                                                      01470000
                                                                        01472000
                                                                        01474000
COMMENT: UNLOCKS THE SPECIFIED RIN.                                     01476000
                                                                        01478000
         RETURNS                                                        01480000
            CCE   OK                                                    01482000
            CCG   IF PROCESS DOES NOT HAVE THE RIN LOCKED FOR ITSELF    01484000
            CCL   IF THE RIN IS NOT ALLOCATED                           01486000
                                                                        01488000
      ;                                                                 01490000
                                                                        01492000
                                                                        01494000
BEGIN                                                                   01496000
      EQUATE RINSIR=38,RINDST=22,ACCX=5;                                01498000
      EQUATE CCG=0,CCL=1,CCE=2;                                         01500000
                                                                        01502000
      INTEGER JPCNTX;                                                   01504000
      ARRAY JGLOF(*)=DB+0;                                              01506000
      INTEGER ARRAY JPCNT(*)=DB+0;                                      01508000
      INTEGER ARRAY PCBX(*)=Q+0;                                        01510000
      INTEGER DB,SIRF,CC,STATUS=Q-1;                                    01512000
      INTEGER X=X;                                                      01514000
                                                                        01516000
                                                                        01518000
      ERRORON;                                                          01520000
      IF RINX < 0 THEN                                         <<01603>>01522000
      BEGIN                                                             01524000
        STATUS.(6:2):=CCL;                                              01526000
        GO BEND;                                                        01528000
      END;                                                              01530000
      SIRF:=GETSIR(RINSIR);            <<BLOCKS RIN>>                   01532000
                                                                        01534000
      GRUNLOCK(RINX);                                          <<01603>>01536000
                                                                        01538000
      IF = THEN                                                         01540000
      BEGIN                            <<OK>>                           01542000
         MRCAPOK(FALSE);               <<RESET GLOBAL RIN FLAG>>        01544000
         CC:=CCE;                                                       01546000
      END ELSE BEGIN PUSH(STATUS);CC:=TOS.(6:2);END;                    01548000
                                                                        01550000
      RELSIR(RINSIR,SIRF);                                              01552000
      STATUS.(6:2):=CC;                                                 01554000
BEND:                                                                   01556000
      ERROREXIT(1,0,0);                                                 01558000
                                                                        01560000
                                                                        01562000
END;  << U N L O C K G L O R I N  >>                                    01564000
                                                                        01566000
<<------------------------------------------------------------------->> 01568000
                                                                        01570000
                                                                        01572000
                                                                        01574000
                                                                        01576000
                                                                        01578000
PROCEDURE FREELOCRIN;                                                   01580000
OPTION PRIVILEGED;                                                      01582000
                                                                        01584000
                                                                        01586000
COMMENT: DEALLOCATES ALL THE RINS ALLOCATED TO A JOB THROUGH            01588000
            GETLOCRIN.                                                  01590000
                                                                        01592000
         RETURNS                                                        01594000
            CCE   OK                                                    01596000
            CCG   NO LOCAL RIN ALLOCATED                                01598000
            CCL   AT LEAST ONE RIN CURRENTLY LOCKED(NOT GRANTED)        01600000
                                                                        01602000
      ;                                                                 01604000
                                                                        01606000
                                                                        01608000
BEGIN                                                                   01610000
      EQUATE RINSIR=38,RINDST=22,JITX=6,FIR=43;                         01612000
      EQUATE CCG=0,CCL=1,CCE=2;                                         01614000
                                                                        01616000
      INTEGER X=X;                                                      01618000
      INTEGER V;                                                        01620000
      INTEGER DB,JIT,FIRST,CC,CX,SIRF;                                  01622000
      INTEGER STATUS=Q-1;                                               01624000
                                                               <<01603>>01626000
      INTEGER ARRAY PCBX(*)=Q+0;                                        01628000
      INTEGER ARRAY JOBINF(*)=DB+0;                                     01630000
      INTEGER RINPTR;                                          <<01603>>01632000
                                                                        01634000
      ERRORON;                                                          01636000
      <<GET THE JIT FROM PCBX>>                                         01638000
      PUSH(Q,DL);                                                       01640000
      ASSEMBLE(XCH,SUB;DUP,STAX;DECX);                                  01642000
      TOS:=-PCBX(X);                                                    01644000
      ASSEMBLE(ADD);                                                    01646000
      TOS:=TOS+JITX;                                                    01648000
      ASSEMBLE(STAX);                                                   01650000
      TOS:=PCBX(X).(6:10);             <<EXTRACT JIT DST>>              01652000
      JIT:=TOS;                                                         01654000
      DB:=EXCHANGEDB(JIT);                                              01656000
      SIRF:=GETSIR(RINSIR);            <<BLOCKS RINS>>                  01658000
                                                                        01660000
      TOS:=JOBINF(FIR);                <<FIRST RIN>>                    01662000
      IF = THEN                                                         01664000
      BEGIN                            <<JOB HAS NO RIN ALLOCATED>>     01666000
         CC:=CCG;                                                       01668000
         GOTO FIN;                                                      01670000
      END;                                                              01672000
      ASSEMBLE(DUP);                                                    01674000
      FIRST:=TOS;                                                       01676000
      JOBINF(X):=0;                    <<RESET FIRST RIN TO 0>>         01678000
                                                                        01680000
      <<TEST TO FIND OUT IF NO RINS ARE STIIL LOCKED>>                  01682000
      CC := CCE; <<DEFAULT>>                                   <<01928>>01684000
      EXCHANGEDB(RINDST);              <<DB TO RIN TABLE>>              01686000
      RINPTR := FIRST*RIN'LENGTH;                              <<01603>>01688000
      WHILE RINPTR <> 0 DO                                     <<01603>>01690000
      BEGIN                                                    <<01603>>01692000
        IF RIN'E'HOLDER <> 0 THEN  << TEST FOR >>              <<01603>>01694000
        BEGIN   << SOMETHING AND TEST FOR LOCKED  >>           <<01603>>01696000
          EXCHANGEDB(JIT);            << DB TO JIT >>          <<01603>>01698000
          JOBINF(FIR) := FIRST;  << RESTORE FIRST RIN >>       <<01603>>01700000
          CC := CCL;                                           <<01928>>01702000
          GOTO FIN;                                            <<01928>>01704000
        END;                                                   <<01603>>01706000
        RINPTR := RIN'E'INDEX*RIN'LENGTH;<< NEXT POINTER >>    <<01603>>01708000
      END;                                                     <<01603>>01710000
      RINPTR := FIRST*RIN'LENGTH;                              <<01603>>01712000
      WHILE RINPTR <> 0 DO                                     <<01603>>01714000
      BEGIN                                                    <<01603>>01716000
        V := RIN'E'INDEX;                                      <<01603>>01718000
        RINPTR := RINPTR/RIN'LENGTH;                           <<01603>>01720000
        RINPTR.(0:1) := 1;  << DB ALREADY POINTING TO RIN T>>  <<01603>>01722000
        DEALLORIN(RINPTR);                                     <<01603>>01724000
        IF < THEN SUDDENDEATH(303);                            <<01603>>01726000
        RINPTR := V*RIN'LENGTH;                                <<01603>>01728000
      END;                                                     <<01603>>01730000
FIN:  RELSIR(RINSIR,SIRF);                                     <<01603>>01732000
      EXCHANGEDB(DB);                                          <<01603>>01734000
      STATUS.(6:2) := CC;                                      <<01928>>01736000
      ERROREXIT(0,0,0);                                        <<01603>>01738000
END;  << F R E E L O C R I N  >>                                        01740000
                                                                        01742000
<<------------------------------------------------------------------->> 01744000
                                                                        01746000
                                                                        01748000
                                                                        01750000
                                                                        01752000
                                                                        01754000
                                                                        01756000
                                                                        01758000
                                                                        01760000
PROCEDURE GETLOCRIN(N);                                                 01762000
VALUE N;                                                                01764000
LOGICAL N;                                                              01766000
OPTION PRIVILEGED;                                                      01768000
                                                                        01770000
                                                                        01772000
COMMENT: ALLOCATES N GLOBAL RINS AND LINKS THEM.                        01774000
         THE FIRST IS KEPT IN JIT (CELL 43).                            01776000
                                                                        01778000
         RETURNS                                                        01780000
            CCE   ALL N RINS HAVE BEEN ALLOCATED                        01782000
            CCG   THE JOB HAS ALREADY LOCAL RINS ALLOCATED(NOT GRANTED) 01784000
            CCL   NOT ENOUGH RINS AVAILABLE:NO RIN ALLOCATED.           01786000
      ;                                                                 01788000
                                                                        01790000
                                                                        01792000
BEGIN                                                                   01794000
      EQUATE CCG=0,CCL=1,CCE=2;                                         01796000
      EQUATE RINSIR=38,RINDST=22,JITX=6,FIR=43,RCODE=%100001;           01798000
                                                                        01800000
      INTEGER X=X,SIRF,DB,CC,CX,PREVIOUS,V,FIRST,STATUS=Q-1;            01802000
      INTEGER ARRAY PCBX(*)=Q+0;                                        01804000
      INTEGER ARRAY JOBINF(*)=DB+0;                                     01806000
      INTEGER JIT;                     <<JIT DST #>>                    01808000
      INTEGER RINPTR;                                          <<01603>>01810000
                                                                        01812000
      ERRORON;                                                          01814000
      DB:=EXCHANGEDB(RINDST);                                           01816000
      SIRF:=GETSIR(RINSIR);                                             01818000
                                                                        01820000
      CC:=CCE;                                                          01822000
      CX := 0;                                                 <<01603>>01824000
      WHILE LOGICAL ((CX := CX+1)) <= N DO                     <<01603>>01826000
      BEGIN                                                    <<01603>>01828000
        RINPTR := ALLORIN(RCODE)*RIN'LENGTH; << RIN INDEX >>   <<01603>>01830000
        IF RINPTR <> 0 THEN << TEST FOR RETURNED VALE >>       <<01603>>01832000
        BEGIN               << SUCESSFUL              >>       <<01603>>01834000
          IF CX = 1 THEN    << TEST FOR START OF CHAIN>>       <<01603>>01836000
          BEGIN                                                <<01603>>01838000
            PUSH(Q,DL);                                        <<01603>>01840000
            ASSEMBLE(XCH,SUB;DUP,STAX;DECX);                   <<01603>>01842000
            TOS := -PCBX(X);                                   <<01603>>01844000
            ASSEMBLE(ADD);                                     <<01603>>01846000
            TOS := TOS+JITX;                                   <<01603>>01848000
            ASSEMBLE(STAX);                                    <<01603>>01850000
            TOS := 0;                                          <<01603>>01852000
            TOS := PCBX(X).(6:10);            << JIT DST >>    <<01603>>01854000
            ASSEMBLE(DUP); JIT := TOS;                         <<01603>>01856000
            EXCHANGEDB(*);                    <<DB TO JIT>>    <<01603>>01858000
            V := JOBINF(FIR);                 << FIRST RIN>>   <<01603>>01860000
            IF V <> 0 THEN     <<LOCAL RINS ALREADY ALLOCATED>><<01603>>01862000
            BEGIN                                              <<01603>>01864000
              EXCHANGEDB(RINDST);  << DB BACK TO RINTABLE >>   <<01603>>01866000
              RIN'E'INDEX := RIN'FIRSTFREE;                    <<01603>>01868000
              RIN'FIRSTFREE := RINPTR;  << DELINK >>           <<01603>>01870000
              RIN'E'TYPE:=0;                                   <<01916>>01872000
              RELSIR(RINSIR,SIRF);                             <<01603>>01874000
              EXCHANGEDB(DB);                                  <<01603>>01876000
              STATUS.(6:2) := CCG;                             <<01603>>01878000
              ERROREXIT(1,0,0);                                <<01603>>01880000
              RETURN;                                          <<01603>>01882000
            END;                                               <<01603>>01884000
            << THER ARE NO LOCAL RINS ALLOCATED >>             <<01603>>01886000
            JOBINF(X) := RINPTR/RIN'LENGTH; <<STORE 1ST RIN >> <<01603>>01888000
            EXCHANGEDB(RINDST);                                <<01603>>01890000
            PREVIOUS := RINPTR;                                <<01603>>01892000
            FIRST := RINPTR;                                   <<01603>>01894000
          END                                                  <<01603>>01896000
          ELSE                                                 <<01603>>01898000
          BEGIN                   << NOT SUCCESSFUL >>         <<01603>>01900000
            V := RINPTR;                                       <<01603>>01902000
            RINPTR := PREVIOUS;                                <<01603>>01904000
            RIN'E'INDEX := V/RIN'LENGTH;                       <<01603>>01906000
            PREVIOUS := V;                                     <<01603>>01908000
            RINPTR := V;                                       <<01603>>01910000
          END                                                  <<01603>>01912000
        END                                                    <<01603>>01914000
        ELSE                                                   <<01603>>01916000
        BEGIN                                                  <<01603>>01918000
          IF CX = 1 THEN                                       <<01603>>01920000
          BEGIN RELSIR(RINSIR,SIRF);                           <<01603>>01922000
            EXCHANGEDB(DB);                                    <<01603>>01924000
            STATUS.(6:2) := CCL;                               <<01603>>01926000
            ERROREXIT(1,0,0);                                  <<01603>>01928000
            RETURN;                                            <<01603>>01930000
          END;                                                 <<01916>>01932000
          RINPTR := FIRST;                                     <<01928>>01934000
          WHILE RINPTR <> 0 DO                                 <<01916>>01936000
          BEGIN                                                <<01916>>01938000
            V := RIN'E'INDEX;                                  <<01916>>01940000
            RINPTR := RINPTR/RIN'LENGTH;                       <<01916>>01942000
            RINPTR.(0:1) := 1;  << DB ALREADY POINTING TO RIN T<<01916>>01944000
            DEALLORIN(RINPTR);                                 <<01916>>01946000
            IF < THEN SUDDENDEATH(303);                        <<01916>>01948000
            RINPTR := V*RIN'LENGTH;                            <<01916>>01950000
          END;                                                 <<01916>>01952000
          EXCHANGEDB(JIT); JOBINF(FIR) := 0;                   <<01603>>01954000
                            << RESET FIRST >>                  <<01603>>01956000
          RELSIR(RINSIR,SIRF);                                 <<01603>>01958000
          EXCHANGEDB(DB);                                      <<01603>>01960000
          STATUS.(6:2) := CCL;                                 <<01603>>01962000
          ERROREXIT(1,0,0);                                    <<01603>>01964000
          RETURN;                                              <<01603>>01966000
        END;                                                   <<01603>>01968000
     END;                                                      <<01603>>01970000
     RELSIR(RINSIR,SIRF);                                      <<01603>>01972000
     EXCHANGEDB(DB);                                           <<01603>>01974000
     STATUS.(6:2) := CCE;                                      <<01603>>01976000
     ERROREXIT(1,0,0);                                         <<01603>>01978000
                                                                        01980000
END;  << G E T L O C R I N  >>                                          01982000
                                                                        01984000
<<------------------------------------------------------------------->> 01986000
                                                                        01988000
                                                                        01990000
                                                                        01992000
                                                                        01994000
                                                                        01996000
                                                                        01998000
                                                                        02000000
INTEGER PROCEDURE LOCKUNLOCKLOCRIN(L,Y,UNCOND);                         02002000
VALUE L,Y,UNCOND;                                                       02004000
INTEGER Y;                                                              02006000
LOGICAL L,UNCOND;                                                       02008000
OPTION PRIVILEGED,UNCALLABLE;                                           02010000
                                                                        02012000
                                                                        02014000
COMMENT: LOCKS OR UNLOCKS A LOCAL RIN(ACCORDING TO L VALUE)             02016000
                                                                        02018000
         RETURNS                                                        02020000
            0,1,2   :CONDITION CODE FROM RLOCK OR RUNLOCK               02022000
            3       IF Y IS OUTSIDE THE SET OF RINS THAT ARE ALLOCATED  02024000
      ;                                                                 02026000
                                                                        02028000
BEGIN                                                                   02030000
      EQUATE RINDST=22,RINSIR=38,JITX=6,FIR=43;                         02032000
                                                                        02034000
      INTEGER DB,SIRF;                                                  02036000
      INTEGER ARRAY PCBX(*)=Q+0;                                        02038000
      ARRAY JOBINF(*)=DB+0;                                             02040000
      INTEGER RINPTR;                                          <<01603>>02042000
      INTEGER STATUS=Q-1,FIRST,CX,CC;                                   02044000
      INTEGER X=X;                                                      02046000
                                                                        02048000
                                                                        02050000
      IF Y=0 THEN                                                       02052000
      BEGIN                            <<INVALID>>                      02054000
         LOCKUNLOCKLOCRIN:=3;                                           02056000
         RETURN;                                                        02058000
      END;                                                              02060000
                                                                        02062000
      <<GET JIT FROM PCBX>>                                             02064000
      PUSH(Q,DL);                                                       02066000
      ASSEMBLE(XCH,SUB;DUP,STAX;DECX);                                  02068000
      TOS:=-PCBX(X);                                                    02070000
      ASSEMBLE(ADD);                                                    02072000
      TOS:=TOS+JITX;                                                    02074000
      ASSEMBLE(STAX);                                                   02076000
      TOS:=PCBX(X).(6:10);             <<EXTRACT JIT DST>>              02078000
      ASSEMBLE(ZERO,XCH);                                               02080000
      DB:=EXCHANGEDB(*);               <<DB TO JIT>>                    02082000
      SIRF:=GETSIR(RINSIR);                                             02084000
      RINPTR := JOBINF(FIR)*RIN'LENGTH;                        <<01603>>02086000
      IF RINPTR = 0 THEN                                       <<01603>>02088000
      BEGIN                                                    <<01603>>02090000
        LOCKUNLOCKLOCRIN := 3;                                 <<01603>>02092000
        RELSIR(RINSIR,SIRF);            <<RELEASE RIN >>       <<01603>>02094000
        EXCHANGEDB(DB);                                        <<01603>>02096000
        RETURN;                                                <<01603>>02098000
      END;                                                     <<01603>>02100000
      EXCHANGEDB(RINDST);            << TO RINTABLE >>         <<01603>>02102000
      CX := 0;                                                 <<01603>>02104000
      WHILE (CX:=CX+1) < Y DO                                  <<01603>>02106000
      BEGIN                                                    <<01603>>02108000
        RINPTR := RIN'E'INDEX*RIN'LENGTH;                      <<01603>>02110000
        IF RINPTR = 0 THEN                                     <<01603>>02112000
        BEGIN                 << CHAIN SOTPS >>                <<01603>>02114000
          LOCKUNLOCKLOCRIN := 3;                               <<01603>>02116000
          RELSIR(RINSIR,SIRF);  <<RELEASE RIN >>               <<01603>>02118000
          EXCHANGEDB(DB);                                      <<01603>>02120000
          RETURN;                                              <<01603>>02122000
        END;                                                   <<01603>>02124000
      END;                                                     <<01603>>02126000
      EXCHANGEDB(DB);                                          <<01603>>02128000
      IF L THEN RLOCK(RINPTR/RIN'LENGTH,UNCOND)                <<01603>>02130000
           ELSE LRUNLOCK(RINPTR/RIN'LENGTH);                   <<01603>>02132000
      PUSH(STATUS);                                            <<01603>>02134000
      LOCKUNLOCKLOCRIN := TOS.(6:2);                           <<01603>>02136000
                                                               <<01603>>02138000
      RELSIR(RINSIR,SIRF);  <<RELEASE RIN >>                   <<01603>>02140000
      EXCHANGEDB(DB);                                                   02142000
                                                                        02144000
                                                                        02146000
END;  << L O C K U N L O C K L O C R I N  >>                            02148000
                                                                        02150000
<<------------------------------------------------------------------->> 02152000
                                                                        02154000
                                                                        02156000
                                                                        02158000
                                                                        02160000
                                                                        02162000
                                                                        02164000
                                                                        02166000
PROCEDURE LOCKLOCRIN(Y,UNCOND);                                         02168000
VALUE Y;                                                                02170000
INTEGER Y;                                                              02172000
LOGICAL UNCOND;                                                         02174000
OPTION PRIVILEGED;                                                      02176000
                                                                        02178000
                                                                        02180000
COMMENT: CALLABLE PROCEDURE TO OCK A LOCAL RIN.                         02182000
                                                                        02184000
         RETURNS                                                        02186000
            CCE   GRANTED                                               02188000
               UNCOND=FALSE IF PROCESS DIDN'T HAVE IT                   02190000
               UNCOND=TRUE IF PROCESS ALREADY HAD IT                    02192000
            CCG   NOT GRANTED(LOCKED BY ANOTHER PROCESS) UNCOND=TRUE    02194000
            CCL   INVALID RIN(TOO BIG,NO LOCAL RIN ALLOCATED,OR Y=0)    02196000
      ;                                                                 02198000
                                                                        02200000
                                                                        02202000
BEGIN                                                                   02204000
      EQUATE CCG=0,CCL=1,CCE=2;                                         02206000
      INTEGER CC,STATUS=Q-1;                                            02208000
                                                                        02210000
      ERRORON;                                                          02212000
                                                               <<01928>>02214000
      IF Y<0 THEN                                              <<01928>>02216000
         BEGIN                                                 <<01928>>02218000
         CC := CCL;                                            <<01928>>02220000
         GOTO BEND;                                            <<01928>>02222000
         END;                                                  <<01928>>02224000
                                                               <<01928>>02226000
      CASE LOCKUNLOCKLOCRIN(1,Y,UNCOND) OF                              02228000
                                                                        02230000
      BEGIN                                                             02232000
         BEGIN UNCOND:=TRUE;CC:=CCE;END;                                02234000
         CC:=CCG;                                                       02236000
         BEGIN UNCOND:=FALSE;CC:=CCE;END;                               02238000
         CC:=CCL;                                                       02240000
      END;                                                              02242000
                                                                        02244000
  BEND:                                                        <<01928>>02246000
      STATUS.(6:2):=CC;                                                 02248000
      ERROREXIT(2,0,0);                                                 02250000
                                                                        02252000
END;  << L O C K L O C R I N  >>                                        02254000
                                                                        02256000
<<------------------------------------------------------------------->> 02258000
                                                                        02260000
                                                                        02262000
                                                                        02264000
                                                                        02266000
                                                                        02268000
                                                                        02270000
PROCEDURE UNLOCKLOCRIN(Y);                                              02272000
VALUE Y;                                                                02274000
INTEGER Y;                                                              02276000
OPTION PRIVILEGED;                                                      02278000
                                                                        02280000
COMMENT: CALLABLE PROCEDURE TO UNLOCK A LOCAL RIN.                      02282000
                                                                        02284000
         RETURN                                                         02286000
            CCE   OK                                                    02288000
            CCG   THE RIN IS LEGAL BUT NOT LOCKED BY CALLER(NOT GRANTED)02290000
            CCL   INVALID RIN(NOT ALLOCATED,TOO BIG OR Y=0)             02292000
      ;                                                                 02294000
                                                                        02296000
BEGIN                                                                   02298000
      INTEGER STATUS=Q-1;                                               02300000
      EQUATE CCG=0,CCL=1,CCE=2;                                         02302000
      ERRORON;                                                          02304000
      IF Y < 0 THEN                                                     02306000
      BEGIN                                                             02308000
        STATUS.(6:2):=CCL;                                              02310000
        GO BEND;                                                        02312000
      END;                                                              02314000
      TOS:=LOCKUNLOCKLOCRIN(0,Y,0);                                     02316000
      ASSEMBLE(DUP,DUP);                                                02318000
      IF TOS AND TOS&LSR(1) THEN TOS:=1;                                02320000
                                                                        02322000
      STATUS.(6:2):=TOS;                                                02324000
BEND:                                                                   02326000
      ERROREXIT(1,0,0);                                                 02328000
END;  << U N L O C K L O C R I N  >>                                    02330000
$PAGE                                                                   02332000
<<------------------------------------------------------------------->> 02334000
                                                                        02336000
                                                                        02338000
                                                                        02340000
                                                                        02342000
                                                                        02344000
INTEGER PROCEDURE LOCRINOWNER (RINX);                          <<01603>>02346000
  VALUE RINX;   INTEGER RINX;                                  <<01603>>02348000
  OPTION PRIVILEGED;                                           <<00452>>02350000
  <<********************************************************>> <<00452>>02352000
  <<                                                        >> <<00452>>02354000
  << PROCEDURE TO DETERMINE PIN OF PROCESS WHICH HAS A      >> <<00452>>02356000
  << PARTICULAR LOCAL RIN LOCKED.  IF FATHER HAS IT LOCKED  >> <<00452>>02358000
  << RETURN 0 OTHERWISE RETURN PIN (EVEN IF THIS PROCESS    >> <<00452>>02360000
  << HAS IT LOCKED).                                        >> <<00452>>02362000
  <<                                                        >> <<00452>>02364000
  <<    CONDITION CODE : CCE - REQUEST GRANTED              >> <<00452>>02366000
  <<                     CCG - RIN NOT CURRENTLY LOCKED     >> <<00452>>02368000
  <<                     CCL - REQUEST DENIED BECAUSE RIN   >> <<00452>>02370000
  <<                           WAS INVALID (WAS <= 0 OR     >> <<00452>>02372000
  <<                           RIN EXCEEDED # OF LOCAL      >> <<00452>>02374000
  <<                           RINS CURRENTLY ALLOCATED)    >> <<00452>>02376000
  <<                                                        >> <<00452>>02378000
  <<********************************************************>> <<00452>>02380000
                                                               <<00452>>02382000
  BEGIN                                                        <<00452>>02384000
    EQUATE INTNUM = 36,  NUMPARMS = 1;                         <<00804>>02386000
    EQUATE ERREX = [10/INTNUM, 6/NUMPARMS];                    <<00804>>02388000
    EQUATE RSLT = %101;                                        <<00804>>02390000
    EQUATE JITX = 6,   FIR = 43,   RINDST = 22,   RINSIR = 38; <<00452>>02392000
    EQUATE CCG = 0,   CCL = 1,   CCE = 2;                      <<00452>>02394000
    INTEGER I, RINPTR, PIN, CC, DB, STATUS = Q-1;              <<01622>>02396000
    LOGICAL SIRCOND;                                           <<00452>>02398000
    INTEGER POINTER JITINPCBX;                                 <<00452>>02400000
    INTEGER ARRAY JIT(*) = DB+0;                               <<00452>>02402000
                                                               <<00452>>02404000
                                                               <<00452>>02406000
    SUBROUTINE GETRINPTR;                                      <<01622>>02408000
                                                               <<01622>>02410000
      COMMENT : SUBROUTINE TO GET POINTER TO LOCAL RINS        <<01622>>02412000
                CURRENTLY ALLOCATED TO THE CALLING PROCESS     <<01622>>02414000
                FROM THE JIT.  JIT DST IS IN PCBX;             <<01622>>02416000
      BEGIN                                                    <<00452>>02418000
        PUSH (DL);                                             <<00452>>02420000
        @JITINPCBX := TOS;                                     <<00452>>02422000
        @JITINPCBX := @JITINPCBX - JITINPCBX(-1) + JITX;       <<00452>>02424000
        TOS := @RINPTR;                                        <<01622>>02426000
        TOS := JITINPCBX.(6:10);     << JIT DST # >>           <<01622>>02428000
        TOS := FIR;                  << OFFSET TO RINS PTR >>  <<01622>>02430000
        TOS := 1;                                              <<01622>>02432000
        ASSEMBLE (MFDS);             << GET THE RIN PTR >>     <<01622>>02434000
        RINPTR := RINPTR * RIN'LENGTH;                         <<01622>>02436000
      END <<GETRINPTR>>;                                       <<00452>>02438000
                                                               <<00452>>02440000
                                                               <<00452>>02442000
    << LOCRINOWNER >>                                          <<00452>>02444000
    FORCESTKO;                                                 <<00804>>02446000
    ERRORON;                                                   <<00804>>02448000
    CHEK (ERREX, RSLT);                                        <<00804>>02450000
    TRAPSOFF;                                                  <<00804>>02452000
    LOCRINOWNER := 0;   CC := CCE;                             <<00452>>02454000
                                                               <<01622>>02456000
    IF RINX <= 0 THEN CC := CCL                                <<01603>>02458000
    ELSE                                                       <<00452>>02460000
      BEGIN                                                    <<00452>>02462000
        GETRINPTR;                                             <<01622>>02464000
        DB := EXCHANGEDB (RINDST);                             <<01622>>02466000
        SIRCOND := GETSIR (RINSIR);                            <<00452>>02468000
        I := 1;                                                <<00452>>02470000
                                                               <<01622>>02472000
        WHILE I < RINX AND RINPTR <> 0 DO                      <<01603>>02474000
          BEGIN                                                <<00452>>02476000
            RINPTR := RIN'E'INDEX * RIN'LENGTH;                <<01622>>02478000
            I := I + 1;                                        <<00452>>02480000
          END;                                                 <<00452>>02482000
                                                               <<01622>>02484000
        IF RINPTR = 0 THEN CC := CCL                           <<00452>>02486000
        ELSE                                                   <<00452>>02488000
          BEGIN                                                <<00452>>02490000
            PIN := RIN'E'HOLDER;                               <<01622>>02492000
            IF PIN = 0 THEN CC := CCG                          <<00452>>02494000
            ELSE IF PIN <> FATHER THEN LOCRINOWNER := PIN;     <<00452>>02496000
          END;                                                 <<00452>>02498000
        RELSIR (RINSIR, SIRCOND);                              <<00452>>02500000
        EXCHANGEDB (DB);                                       <<00452>>02502000
      END;                                                     <<00452>>02504000
                                                               <<01622>>02506000
    STATUS.(6:2) := CC;                                        <<00452>>02508000
    ERROREXIT (ERREX, 0, 0);                                   <<00804>>02510000
  END << LOCRINOWNER >>;                                       <<00452>>02512000
                                                                        02514000
<<------------------------------------------------------------------->> 02516000
                                                                        02518000
$CONTROL SEGMENT=MAIN                                                   02520000
                                                                        02522000
                                                                        02524000
                                                                        02526000
                                                                        02528000
END ; <<O F    R I N    I N T R I N S I C     F I L E   >>              02530000
