DCL SPCPTR .PARM1 PARM;
DCL DD PARM1 CHAR(20) BAS(.PARM1);
    DCL DD PARM-HASH  CHAR(20) DEF(PARM1) POS(1);

DCL SPCPTR .PARM2 PARM;
DCL DD PARM2 CHAR(90) BAS(.PARM2);
    DCL DD PARM-MAX-YIELDS BIN(4) DEF(PARM2) POS( 1); /* DFLT = 1000 */
    DCL DD PARM-CONFIDENCE BIN(4) DEF(PARM2) POS( 5); /* > 80%: GOOD */
    DCL DD PARM-RESTART   CHAR(1) DEF(PARM2) POS( 9); /*    Y OR N   */
    DCL DD PARM-PHRASE   CHAR(64) DEF(PARM2) POS(10); /* USER SUPPL. */
    DCL DD PARM-CALLS   PKD(21,0) DEF(PARM2) POS(74); /* NBR OF CALLS*/
    DCL DD *              CHAR(6) DEF(PARM2) POS(85); /*    UNUSED   */

DCL SPCPTR .PARM3 PARM;
DCL DD PARM3 CHAR(640) BAS(.PARM3);
    DCL DD PARM-STATE    CHAR(640) DEF(PARM3) POS(1);

DCL OL PARMS(.PARM1, .PARM2, .PARM3) PARM EXT MIN(2);

DCL SPCPTR .STATE INIT(STATE);
DCL DD STATE CHAR(640) BDRY(16);
    DCL DD CURRENT         CHAR(90) DEF(STATE) POS(  1);
        DCL DD CUR-MAX-YIELDS   BIN(4) DEF(CURRENT) POS( 1) INIT(1000);
        DCL DD CUR-CONFIDENCE   BIN(4) DEF(CURRENT) POS( 5); /* N/A */
        DCL DD CUR-RESTART     CHAR(1) DEF(CURRENT) POS( 9) INIT("N");
        DCL DD CUR-PHRASE     CHAR(64) DEF(CURRENT) POS(10);
        DCL DD *              CHAR(17) DEF(CURRENT) POS(74);

    DCL DD NBR-OF-CALLS   PKD(21,0) DEF(STATE) POS( 91) INIT(P'0');
    DCL DD NBR-OF-PARMS      BIN(2) DEF(STATE) POS(103);
    DCL DD POOL-POSITION     BIN(4) DEF(STATE) POS(105) INIT(1);
    DCL DD LAST-YIELDS       BIN(4) DEF(STATE) POS(109) INIT(0);

    DCL DD ENTROPY-POOL-SIZE BIN(2) DEF(STATE) POS(113) INIT(500);
    DCL DD ENTROPY-POOL   CHAR(500) DEF(STATE) POS(115);
    DCL DD POOL-STEP         BIN(2) DEF(STATE) POS(615) INIT(0);
    DCL DD PREVIOUS-HASH   CHAR(20) DEF(STATE) POS(621);
        DCL DD PRV-HASH-LO   BIN(2) UNSGND DEF(PREVIOUS-HASH) POS(19);

DCL INSPTR .RETURN;

/************************** GET ENTROPY ****************************/

ENTRY * (PARMS) EXT;
    STPLLEN      NBR-OF-PARMS;
    CPYBLA       CURRENT, PARM2;
    ADDN(S)      NBR-OF-CALLS, 1;
    CPYNV        PARM-CALLS, NBR-OF-CALLS;

    CMPBLA(B)    CUR-RESTART, "Y"/NEQ(GET-MACHINE-ACTIVITY);
    CPYBREP      PREVIOUS-HASH, X'00';
    CPYBREP      ENTROPY-POOL,  X'00';
    CPYNV        POOL-STEP,       0;
    CPYNV        POOL-POSITION,   1;

GET-MACHINE-ACTIVITY:
    CALLI        GET-THREAD-ACTIVITY,        *, .RETURN;
    CALLI        GET-PROCESSOR-UTILIZATION,  *, .RETURN;
    CALLI        GET-STORAGE-USAGE-COUNTERS, *, .RETURN;
    CALLI        GET-STORAGE-POOL-ACTIVITY,  *, .RETURN;
    CALLI        GET-DISK-ACTIVITY-COUNTERS, *, .RETURN;
    CALLI        GET-MULTIPROGRAMMING-LEVELS,*, .RETURN;

    CALLI        ESTIMATE-ENTROPY-ADDED, *, .RETURN;

RETURN-CONTROL-VARIABLES:
    CMPNV(B)     NBR-OF-PARMS, 3/NEQ(=+4);
    CMPBLA(B)    CUR-RESTART, "Y"/EQ(=+3);
    CMPBLA(B)    PARM-HASH, PREVIOUS-HASH/EQ(=+2);
    CPYNV        NBR-OF-PARMS, 2;:

    CPYBLA       CUR-RESTART, "N";
    CPYBLA       PARM-RESTART,    CUR-RESTART;
    CPYNV        PARM-CONFIDENCE, CUR-CONFIDENCE;

MAKE-FINAL-HASH:
    CPYBREP      CIPHER-WORKAREA, X'00';
    CPYNV        CIPHER-LENGTH,    640;
    CIPHER      .PARM1, CIPHER-OPTS, .STATE;
    CPYBLA       PREVIOUS-HASH, PARM-HASH;

    CMPNV(B)     NBR-OF-PARMS, 3/NEQ(=+2);
    CPYBLA       PARM3, STATE;:

    RTX          *;

/*******************== PROCESS THREAD ACTIVITY ==*******************/

DCL SPCPTR .P24-ATTR INIT(P24-ATTR);
DCL DD  P24-ATTR CHAR(128) BDRY(16);
    DCL DD  P24-MAX-SIZE          BIN(4)        DEF(P24-ATTR) POS( 1);
    DCL DD  P24-ACT-SIZE          BIN(4)        DEF(P24-ATTR) POS( 5);
    DCL DD  P24-CPU-TIME-USED    CHAR(8)        DEF(P24-ATTR) POS(19);

ENTRY GET-THREAD-ACTIVITY INT;
    CPYNV        P24-MAX-SIZE, 128;
    MATPRATR    .P24-ATTR, *, X'24'; /* THREAD ACTIVITY */

    CPYBLA       TIME-VALUE, P24-CPU-TIME-USED;
    CALLI        ADD-TIME-TO-ENTROPY, *, .ADD-TIME-TO-ENTROPY;

    CPYNV        ENTROPY-VALUE, NBR-OF-CALLS;
    CALLI        ADD-TO-ENTROPY-POOL, *, .ADD-TO-ENTROPY-POOL;
    B           .RETURN;

/*******************== SYSTEM RESOURCE USAGE ==*********************/

DCL DD WHICH-RESOURCE CHAR(8) INIT(X'0000000000000000');
DCL SPCPTR .RESOURCES INIT(RESOURCES);
DCL DD  RESOURCES CHAR(5016) BDRY(16);
    DCL DD  RMD-MAX-SIZE   BIN(4) DEF(RESOURCES) POS( 1) INIT(5016);
    DCL DD  RMD-ACT-SIZE   BIN(4) DEF(RESOURCES) POS( 5);
    DCL DD  RMD-TIMESTAMP CHAR(8) DEF(RESOURCES) POS( 9);
    DCL DD  RMD-DATA   CHAR(5000) DEF(RESOURCES) POS(17);

/********************* PROCESSOR UTILIZATION ***********************/

DCL DD RMD-PROCESSOR-TIME CHAR(8)  DEF(RMD-DATA) POS( 1);

ENTRY GET-PROCESSOR-UTILIZATION INT;
    CPYBLA       WHICH-RESOURCE, X'01';        /* PROCESSOR UTIL   */
    MATRMD      .RESOURCES, WHICH-RESOURCE;

    CPYBLA       TIME-VALUE, RMD-PROCESSOR-TIME;
    CALLI        ADD-TIME-TO-ENTROPY, *, .ADD-TIME-TO-ENTROPY;
    B           .RETURN;

/********************** STORAGE USAGE COUNTERS *********************/

DCL DD RMD-ACCESS-PENDING  BIN(2) UNSGND DEF(RMD-DATA) POS( 1);
DCL DD RMD-STG-POOL-DELAYS BIN(2) UNSGND DEF(RMD-DATA) POS( 3);
DCL DD RMD-DIR-LOOKUPS     BIN(4) UNSGND DEF(RMD-DATA) POS( 5);
DCL DD RMD-DIR-PFAULTS     BIN(4) UNSGND DEF(RMD-DATA) POS( 9);
DCL DD RMD-AG-MBR-PFAULTS  BIN(4) UNSGND DEF(RMD-DATA) POS(13);
DCL DD RMD-LIC-PFAULTS     BIN(4) UNSGND DEF(RMD-DATA) POS(17);
DCL DD RMD-TASK-READS      BIN(4) UNSGND DEF(RMD-DATA) POS(21);
DCL DD RMD-TASK-WRITES     BIN(4) UNSGND DEF(RMD-DATA) POS(25);
DCL DD RMD-RESERVED1       BIN(4) UNSGND DEF(RMD-DATA) POS(29);

ENTRY GET-STORAGE-USAGE-COUNTERS INT;
    CPYBLA       WHICH-RESOURCE, X'03';        /* STORAGE COUNTERS */
    MATRMD      .RESOURCES, WHICH-RESOURCE;
    CPYNV        ACCUMULATOR, 0;

    ADDN(S)      ACCUMULATOR, RMD-RESERVED1;
    ADDN(S)      ACCUMULATOR, RMD-ACCESS-PENDING;
    ADDN(S)      ACCUMULATOR, RMD-STG-POOL-DELAYS;
    MULT(S)      ACCUMULATOR, 10;

    ADDN(S)      ACCUMULATOR, RMD-DIR-PFAULTS;
    ADDN(S)      ACCUMULATOR, RMD-AG-MBR-PFAULTS;
    ADDN(S)      ACCUMULATOR, RMD-LIC-PFAULTS;
    MULT(S)      ACCUMULATOR, 100;

    ADDN(S)      ACCUMULATOR, RMD-TASK-READS;
    ADDN(S)      ACCUMULATOR, RMD-TASK-WRITES;
    MULT(S)      ACCUMULATOR, 1000;

    ADDN(S)      ACCUMULATOR, RMD-DIR-LOOKUPS;

    CPYNV        ENTROPY-VALUE, ACCUMULATOR;
    CALLI        ADD-TO-ENTROPY-POOL, *, .ADD-TO-ENTROPY-POOL;
    B           .RETURN;

/******************** STORAGE POOL ACTIVITY ************************/

DCL DD RMD-NBR-OF-POOLS     BIN(2) UNSGND DEF(RMD-DATA) POS( 5);
DCL DD RMD-POOLS(100)     CHAR(32)        DEF(RMD-DATA) POS(17);

DCL DD FOR-THIS-POOL PKD(21,0);
DCL DD POOL-NBR BIN(2) UNSGND;
DCL DD THE-POOL CHAR(32);
    DCL DD POOL-DATA-WRITTEN   BIN(4) UNSGND DEF(THE-POOL) POS( 5);
    DCL DD POOL-THREAD-INT-DB  BIN(4) UNSGND DEF(THE-POOL) POS( 9);
    DCL DD POOL-THREAD-INT-NON BIN(4) UNSGND DEF(THE-POOL) POS(13);
    DCL DD POOL-DATA-POOL-DB   BIN(4) UNSGND DEF(THE-POOL) POS(17);
    DCL DD POOL-DATA-POOL-NON  BIN(4) UNSGND DEF(THE-POOL) POS(21);

ENTRY GET-STORAGE-POOL-ACTIVITY INT;
    CPYBLA       WHICH-RESOURCE, X'09';        /* STORAGE POOLS    */
    MATRMD      .RESOURCES, WHICH-RESOURCE;
    CPYNV        ACCUMULATOR, 0;

    CPYNV        POOL-NBR, 1;
FOR-NEXT-POOL:
    CPYNV        FOR-THIS-POOL, 0;
    CMPNV(B)     POOL-NBR,  RMD-NBR-OF-POOLS/HI(DONE-WITH-POOL);
    CPYBLA       THE-POOL,  RMD-POOLS(POOL-NBR);
    CMPBLAP(B)   THE-POOL, X'00', X'00'/EQ(=+2);
    MULT(RS)     ACCUMULATOR, P'1.2345';:

    ADDN(S)      FOR-THIS-POOL, POOL-DATA-WRITTEN;
    MULT(S)      FOR-THIS-POOL, 10;

    ADDN(S)      FOR-THIS-POOL, POOL-THREAD-INT-DB;
    ADDN(S)      FOR-THIS-POOL, POOL-THREAD-INT-NON;
    MULT(S)      FOR-THIS-POOL, 1000;

    ADDN(S)      FOR-THIS-POOL, POOL-DATA-POOL-DB;
    ADDN(S)      FOR-THIS-POOL, POOL-DATA-POOL-NON;
    ADDN(S)      ACCUMULATOR, FOR-THIS-POOL;
    ADDN(SB)     POOL-NBR, 1/POS(FOR-NEXT-POOL);
DONE-WITH-POOL:

    CPYNV        ENTROPY-VALUE, ACCUMULATOR;
    CALLI        ADD-TO-ENTROPY-POOL, *, .ADD-TO-ENTROPY-POOL;
    B           .RETURN;

/********************* DISK ACTIVITY COUNTERS **********************/

DCL DD FOR-THIS-DISK PKD(21,0);
DCL DD DISK-NBR BIN(2) UNSGND;
DCL DD RMD-NBR-OF-DISKS     BIN(2) UNSGND DEF(RMD-DATA) POS( 3);
DCL DD RMD-OFFSET-TO-DISKS  BIN(4) UNSGND DEF(RMD-DATA) POS(29);

DCL SPCPTR .THE-DISK;
DCL DD THE-DISK CHAR(208) BAS(.THE-DISK);
    DCL DD DISK-UNIT-ID     CHAR(22)        DEF(THE-DISK) POS(123);
    DCL DD DISK-BLOCKS-IN     BIN(4) UNSGND DEF(THE-DISK) POS(145);
    DCL DD DISK-BLOCKS-OUT    BIN(4) UNSGND DEF(THE-DISK) POS(149);
    DCL DD DISK-REQIO-IN      BIN(4) UNSGND DEF(THE-DISK) POS(153);
    DCL DD DISK-REQIO-OUT     BIN(4) UNSGND DEF(THE-DISK) POS(157);
    DCL DD DISK-PERM-BLKS-OUT BIN(4) UNSGND DEF(THE-DISK) POS(161);
    DCL DD DISK-REQIO-PERMS   BIN(4) UNSGND DEF(THE-DISK) POS(165);
    DCL DD *                 CHAR(8)        DEF(THE-DISK) POS(169);
    DCL DD DISK-QUEUE-SAMPLED BIN(4) UNSGND DEF(THE-DISK) POS(177);
    DCL DD DISK-QUEUE-EMPTY   BIN(4) UNSGND DEF(THE-DISK) POS(181);

ENTRY GET-DISK-ACTIVITY-COUNTERS INT;
    MULT(R)      ACCUMULATOR, LAST-YIELDS, PRV-HASH-LO;
    CPYBLA       TIME-VALUE, RMD-TIMESTAMP;
    DIV(SB)      TIME-VALUE-LO, TWO**15/EQ(=+2);
    MULT(S)      ACCUMULATOR, TIME-VALUE-LO;:
    REM(SB)      LAST-YIELDS, 4/NZER(DONE-WITH-DISKS);

    CPYBLA       WHICH-RESOURCE, X'12';        /* DISK UTILIZATION */
    MATRMD      .RESOURCES, WHICH-RESOURCE;
    CPYNV        ACCUMULATOR, 0;

    SETSPP      .THE-DISK,  RESOURCES;
    ADDSPP      .THE-DISK, .THE-DISK, RMD-OFFSET-TO-DISKS;
    CPYNV        DISK-NBR,  1;
FOR-NEXT-DISK:
    CPYNV        FOR-THIS-DISK, 0;
    CMPNV(B)     DISK-NBR,  RMD-NBR-OF-DISKS/HI(DONE-WITH-DISKS);
    MULT(RS)     ACCUMULATOR, P'1.2345';

    ADDN(S)      FOR-THIS-DISK, DISK-QUEUE-SAMPLED;
    ADDN(S)      FOR-THIS-DISK, DISK-QUEUE-EMPTY;
    MULT(S)      FOR-THIS-DISK, 100;

    ADDN(S)      FOR-THIS-DISK, DISK-PERM-BLKS-OUT;
    ADDN(S)      FOR-THIS-DISK, DISK-REQIO-PERMS;
    ADDN(S)      FOR-THIS-DISK, DISK-BLOCKS-OUT;
    ADDN(S)      FOR-THIS-DISK, DISK-REQIO-OUT;
    MULT(S)      FOR-THIS-DISK, 1000;

    ADDN(S)      FOR-THIS-DISK, DISK-BLOCKS-IN;
    ADDN(S)      FOR-THIS-DISK, DISK-REQIO-IN;

    ADDN(S)      ACCUMULATOR, FOR-THIS-DISK;
    ADDSPP      .THE-DISK, .THE-DISK, 208;
    ADDN(SB)     DISK-NBR, 1/POS(FOR-NEXT-DISK);
DONE-WITH-DISKS:

    CPYNV        ENTROPY-VALUE, ACCUMULATOR;
    CALLI        ADD-TO-ENTROPY-POOL, *, .ADD-TO-ENTROPY-POOL;
    B           .RETURN;

/********************* MULTIPROGRAMMING LEVELS *********************/

DCL DD FOR-THIS-MPL PKD(21,0);
DCL DD MPL-NBR BIN(2) UNSGND;
DCL DD OFFSET-TO-MPLS BIN(4) INIT(20);
DCL DD RMD-NBR-OF-MPLS      BIN(2) UNSGND DEF(RMD-DATA) POS(3);

DCL SPCPTR .THE-MPL;
DCL DD THE-MPL CHAR(32) BAS(.THE-MPL);
    DCL DD MPL-CURRENT-MPL        BIN(4) UNSGND DEF(THE-MPL) POS( 9);
    DCL DD MPL-NBR-OF-THREADS     BIN(4) UNSGND DEF(THE-MPL) POS(17);
    DCL DD MPL-NBR-ACT-WAIT-TRANS BIN(4) UNSGND DEF(THE-MPL) POS(25);

ENTRY GET-MULTIPROGRAMMING-LEVELS INT;
    CPYBLA       WHICH-RESOURCE, X'16';        /* MPL CONTROL INFO */
    MATRMD      .RESOURCES, WHICH-RESOURCE;
    CPYNV        ACCUMULATOR, 0;

    SETSPP      .THE-MPL,  RMD-DATA;
    ADDSPP      .THE-MPL, .THE-MPL, OFFSET-TO-MPLS;
    CPYNV        MPL-NBR,  1;
FOR-NEXT-MPL:
    CPYNV        FOR-THIS-MPL, 0;
    CMPNV(B)     MPL-NBR, RMD-NBR-OF-MPLS/HI(DONE-WITH-MPLS);
    CMPNV(B)     MPL-CURRENT-MPL, 0/EQ(=+2);
    MULT(RS)     ACCUMULATOR, P'1.2345';:

    ADDN(S)      FOR-THIS-MPL, MPL-NBR-OF-THREADS;
    MULT(S)      FOR-THIS-MPL, 10;
    ADDN(S)      FOR-THIS-MPL, MPL-NBR-ACT-WAIT-TRANS;

    ADDN(S)      ACCUMULATOR, FOR-THIS-MPL;
    ADDSPP      .THE-MPL, .THE-MPL, 32;
    ADDN(SB)     MPL-NBR, 1/POS(FOR-NEXT-MPL);
DONE-WITH-MPLS:

    CPYNV        ENTROPY-VALUE, ACCUMULATOR;
    CALLI        ADD-TO-ENTROPY-POOL, *, .ADD-TO-ENTROPY-POOL;
    B           .RETURN;

/********************* ESTIMATE ENTROPY ADDED **********************/

DCL SPCPTR .COMPRESS-CONTROL INIT(COMPRESS-CONTROL);
DCL DD      COMPRESS-CONTROL CHAR(64) BDRY(16);
    DCL DD  CMPR-SOURCE-LENGTH   BIN(4) DEF(COMPRESS-CONTROL) POS( 1);
    DCL DD  CMPR-BYTES-AVAILABLE BIN(4) DEF(COMPRESS-CONTROL) POS( 5);
    DCL DD  CMPR-LENGTH          BIN(4) DEF(COMPRESS-CONTROL) POS( 9);
    DCL DD  CMPR-ALGORITHM       BIN(2) DEF(COMPRESS-CONTROL) POS(13);
    DCL DD  CMPR-MBZ           CHAR(18) DEF(COMPRESS-CONTROL) POS(15);
    DCL SPCPTR .CMPR-SOURCE             DEF(COMPRESS-CONTROL) POS(33)
                                        INIT(ENTROPY-POOL);
    DCL SPCPTR .CMPR-RESULT             DEF(COMPRESS-CONTROL) POS(49)
                                        INIT(ENTROPY-COMPRESSED);
DCL DD FP   BIN(2);
DCL DD SIZE BIN(2);
DCL DD ENTROPY-COMPRESSED CHAR(600);

ENTRY ESTIMATE-ENTROPY-ADDED INT;
    CMPNV(B)     POOL-STEP, 0/NEQ(=+2); /* SIZE OF EACH ENTRY */
    SUBN         POOL-STEP, POOL-POSITION, 1;:

    CPYNV        CMPR-SOURCE-LENGTH, POOL-POSITION;
    CPYNV        CMPR-BYTES-AVAILABLE, 600;
    CPYNV        CMPR-ALGORITHM, 2; /* LZ1 */
    CPYBREP      CMPR-MBZ, X'00';
    CPRDATA     .COMPRESS-CONTROL;

    CPYBREP      ENTROPY-COMPRESSED, X'00';
    SUBN(S)      CMPR-LENGTH, 12; /* - FIXED OVERHEAD */
    MULT(S)      CMPR-LENGTH, 100;
    DIV(R)       CUR-CONFIDENCE, CMPR-LENGTH, CMPR-SOURCE-LENGTH;

    SUBN         FP, ENTROPY-POOL-SIZE, POOL-STEP;
    CMPNV(B)     POOL-POSITION, FP/LO(.RETURN);

POOL-IS-FILLED:
    SUBN(S)      POOL-POSITION, POOL-STEP;
    SUBN         SIZE, POOL-POSITION, 1;
    ADDN         FP, POOL-STEP, 1;
    CPYBOLAP     ENTROPY-POOL (1:SIZE), ENTROPY-POOL (FP:SIZE), X'00';
    B           .RETURN;

/************************* ENTROPY MANAGEMENT **********************/

DCL DD TIME-TIMES CHAR(24) BDRY(8);
    DCL DD TIME-BEFORE       CHAR(8) DEF(TIME-TIMES) POS( 1);
    DCL DD TIME-AFTER        CHAR(8) DEF(TIME-TIMES) POS( 9);
    DCL DD TIME-VALUE        CHAR(8) DEF(TIME-TIMES) POS(17);
        DCL DD TIME-VALUE-HI  BIN(4) UNSGND DEF(TIME-VALUE) POS(1);
        DCL DD TIME-VALUE-LO  BIN(4) UNSGND DEF(TIME-VALUE) POS(5);

DCL DD TIMESTAMP  PKD(21,0); /* CAN HOLD UNSIGNED 64-BIT INTEGER */
DCL DD TWO**32    PKD(11,0) INIT(P'4294967296');
DCL DD TWO**31    PKD(11,0) INIT(P'2147483648');
DCL DD TWO**15    PKD(11,0) INIT(P'32768');

DCL DD MACHINE-CLOCK CHAR(2) INIT(X'0100');
DCL SPCPTR .MACHINE-ATTR INIT(MACHINE-ATTR);
DCL DD      MACHINE-ATTR CHAR(16) BDRY(16);
    DCL DD  MAT-MAX-SIZE   BIN(4) DEF(MACHINE-ATTR)  POS( 1) INIT(16);
    DCL DD  MAT-ACT-SIZE   BIN(4) DEF(MACHINE-ATTR)  POS( 5);
    DCL DD  MAT-TIMESTAMP CHAR(8) DEF(MACHINE-ATTR)  POS( 9);

DCL INSPTR .ADD-TIME-TO-ENTROPY;
ENTRY       ADD-TIME-TO-ENTROPY INT;
    MULT         TIMESTAMP, TIME-VALUE-HI, TWO**32;
    ADDN(S)      TIMESTAMP, TIME-VALUE-LO;
    DIV          ENTROPY-VALUE, TIMESTAMP, TWO**15;
    CALLI        ADD-TO-ENTROPY-POOL, *, .ADD-TO-ENTROPY-POOL;
    B           .ADD-TIME-TO-ENTROPY;

/*** ADD TO POOL ***/

DCL SPCPTR .ENTROPY-POOL INIT(ENTROPY-POOL);
DCL SPCPTR .SHA-HASH     INIT(SHA-HASH);

DCL DD SHA-HASH CHAR(20);
    DCL DD SHA-HASH-MIDDLE  BIN(4) UNSGND DEF(SHA-HASH) POS(9);

DCL DD CIPHER-OPTS CHAR(32) BDRY(16);
    DCL DD CIPHER-FUNCT  CHAR(2) DEF(CIPHER-OPTS) POS(1) INIT(X'0005');
    DCL DD CIPHER-ALGRTM CHAR(1) DEF(CIPHER-OPTS) POS(3) INIT(X'01');
    DCL DD CIPHER-ONLY   CHAR(1) DEF(CIPHER-OPTS) POS(4) INIT(X'00');
    DCL DD CIPHER-LENGTH  BIN(4) DEF(CIPHER-OPTS) POS(5);
    DCL DD CIPHER-MBZ    CHAR(8) DEF(CIPHER-OPTS) POS(9) INIT(X'00');
    DCL SPCPTR .CIPHER-WORKAREA  DEF(CIPHER-OPTS) POS(17)
                                 INIT(CIPHER-WORKAREA);
DCL DD CIPHER-WORKAREA CHAR(96);
DCL DD TIMES-TO-YIELD  BIN(4) INIT(0);
DCL DD ENTROPY-BITS    BIN(4) UNSGND;
DCL DD ENTROPY-VALUE   PKD(31,0);
DCL DD ACCUMULATOR     PKD(31,0);

DCL INSPTR .ADD-TO-ENTROPY-POOL;
ENTRY       ADD-TO-ENTROPY-POOL INT;
    REM          ENTROPY-BITS, ENTROPY-VALUE, TWO**31;
    CPYBLA       ENTROPY-POOL(POOL-POSITION:4), ENTROPY-BITS;

    CPYBREP      CIPHER-WORKAREA, X'00';
    CPYNV        CIPHER-LENGTH, POOL-POSITION;
    CIPHER      .SHA-HASH, CIPHER-OPTS, .ENTROPY-POOL;

    REM          TIMES-TO-YIELD, SHA-HASH-MIDDLE, CUR-MAX-YIELDS;
    MATMATR     .MACHINE-ATTR, X'0100';
    CPYBLA       TIME-BEFORE, MAT-TIMESTAMP;

    CPYNV        LAST-YIELDS, TIMES-TO-YIELD;
:   YIELD;       SUBN(SB) TIMES-TO-YIELD, 1/HI(=-1);

    MATMATR     .MACHINE-ATTR, X'0100';
    CPYBLA       TIME-AFTER, MAT-TIMESTAMP;

    SUBLC        TIME-VALUE, TIME-AFTER, TIME-BEFORE;
    MULT         TIMESTAMP,  TIME-VALUE-HI, TWO**32;
    ADDN(S)      TIMESTAMP,  TIME-VALUE-LO;
    DIV          ENTROPY-VALUE,  TIMESTAMP, TWO**15;

    REM          ENTROPY-BITS, ENTROPY-VALUE, TWO**31;
    ADDN(S)      POOL-POSITION, 4;
    CPYBLA       ENTROPY-POOL(POOL-POSITION:4), ENTROPY-BITS;
    ADDN(SB)     POOL-POSITION, 4/POS(.ADD-TO-ENTROPY-POOL);