*> ============================================================
      *> 16-matching-2stage-1-1 : 二级请求书核对 (2-Stage Invoice Rec)
      *> Input : FILE-A (file-a.dat: 请求书), FILE-B (file-b.dat: 支付), FILE-C (file-c.dat: 参照)
      *> Output: FINAL-OUT (final.dat: 二级核对结果)
      *>         error.dat (一级/二级未匹配记录)
      *>         audit-report.txt (审计报告: 处理统计)
      *> Coverage: AM-N001, AM-A001, AM-R001
      *>           stage-level control totals, inter-stage reconciliation,
      *>           stage timing measurement, audit trail
      *> ============================================================
       IDENTIFICATION DIVISION.
       PROGRAM-ID. Match2Stage.

       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
      *> Stage 1 files
           SELECT FILE-A ASSIGN TO 'file-a.dat'
               ORGANIZATION IS SEQUENTIAL
               ACCESS MODE IS SEQUENTIAL
               FILE STATUS IS WS-A-STATUS.
           SELECT FILE-B ASSIGN TO 'file-b.dat'
               ORGANIZATION IS SEQUENTIAL
               ACCESS MODE IS SEQUENTIAL
               FILE STATUS IS WS-B-STATUS.
           SELECT TEMP-FILE ASSIGN TO 'temp.dat'
               ORGANIZATION IS SEQUENTIAL
               FILE STATUS IS WS-TEMP-STATUS.
      *> Stage 2 files
           SELECT FILE-C ASSIGN TO 'file-c.dat'
               ORGANIZATION IS SEQUENTIAL
               ACCESS MODE IS SEQUENTIAL
               FILE STATUS IS WS-C-STATUS.
           SELECT FINAL-OUT ASSIGN TO 'final.dat'
               ORGANIZATION IS SEQUENTIAL
               FILE STATUS IS WS-FINAL-STATUS.
           SELECT FILE-ERR ASSIGN TO 'error.dat'
               ORGANIZATION IS SEQUENTIAL
               FILE STATUS IS WS-ERR-STATUS.
           SELECT AUDIT-FILE ASSIGN TO 'audit-report.txt'
               ORGANIZATION IS LINE SEQUENTIAL
               FILE STATUS IS WS-AUDIT-STATUS.

       DATA DIVISION.
       FILE SECTION.
       FD FILE-A.
       01 A-REC.
           COPY "STD-REC.cpy".
       FD FILE-B.
       01 B-REC.
           COPY "STD-REC.cpy".
       FD TEMP-FILE.
       01 TEMP-REC.
           COPY "STD-REC.cpy".
       FD FILE-C.
       01 C-REC.
           COPY "STD-REC.cpy".
       FD FINAL-OUT.
       01 FINAL-REC.
           COPY "STD-REC.cpy".
       FD FILE-ERR.
       01 ERR-REC.
           05 ERR-STAGE       PIC X(10).
           05 ERR-KEY         PIC X(10).
           05 ERR-AMOUNT      PIC 9(10).
           05 ERR-FILLER      PIC X(50).
       FD AUDIT-FILE.
       01 AUDIT-REC           PIC X(120).

       WORKING-STORAGE SECTION.
       01 WS-TELECOM-REC.
           COPY "telecom/TEL-INVOICE.cpy".

      *> File status
       01 WS-A-STATUS     PIC X(02).
       01 WS-B-STATUS     PIC X(02).
       01 WS-TEMP-STATUS  PIC X(02).
       01 WS-C-STATUS     PIC X(02).
       01 WS-FINAL-STATUS PIC X(02).
       01 WS-ERR-STATUS   PIC X(02).
       01 WS-AUDIT-STATUS PIC X(02).

      *> EOF flags
       01 WS-EOF-A       PIC X(01) VALUE 'N'.
          88 WS-EOF-A-YES          VALUE 'Y' FALSE 'N'.
       01 WS-EOF-B       PIC X(01) VALUE 'N'.
          88 WS-EOF-B-YES          VALUE 'Y' FALSE 'N'.
       01 WS-EOF-TEMP    PIC X(01) VALUE 'N'.
          88 WS-EOF-TEMP-YES       VALUE 'Y' FALSE 'N'.
       01 WS-EOF-C       PIC X(01) VALUE 'N'.
          88 WS-EOF-C-YES          VALUE 'Y' FALSE 'N'.

      *> Key variables
       01 WS-KEY-A       PIC X(10).
       01 WS-KEY-B       PIC X(10).
       01 WS-KEY-TEMP    PIC X(10).
       01 WS-KEY-C       PIC X(10).
       01 WS-PREV-KEY-A  PIC X(10).
       01 WS-PREV-KEY-B  PIC X(10).

      *> Counters
       01 WS-STAGE1-COUNT PIC 9(05) VALUE ZERO.
       01 WS-STAGE2-COUNT PIC 9(05) VALUE ZERO.
       01 WS-A-READ-COUNT PIC 9(05) VALUE ZERO.
       01 WS-B-READ-COUNT PIC 9(05) VALUE ZERO.
       01 WS-C-READ-COUNT PIC 9(05) VALUE ZERO.
       01 WS-UNMATCH-A    PIC 9(05) VALUE ZERO.
       01 WS-UNMATCH-B    PIC 9(05) VALUE ZERO.
       01 WS-UNMATCH-TEMP PIC 9(05) VALUE ZERO.
       01 WS-UNMATCH-C    PIC 9(05) VALUE ZERO.
       01 WS-WARN-COUNT   PIC 9(05) VALUE ZERO.
       01 WS-FATAL-COUNT  PIC 9(05) VALUE ZERO.
       01 WS-SEQ-ERR-COUNT PIC 9(05) VALUE ZERO.

      *> Hash totals
       01 WS-HASH-TOTALS.
           05 WS-HASH-A-INPUT      PIC 9(15) VALUE ZERO.
           05 WS-HASH-B-INPUT      PIC 9(15) VALUE ZERO.
           05 WS-HASH-TEMP         PIC 9(15) VALUE ZERO.
           05 WS-HASH-C-INPUT      PIC 9(15) VALUE ZERO.
           05 WS-HASH-FINAL        PIC 9(15) VALUE ZERO.
           05 WS-HASH-ERR          PIC 9(15) VALUE ZERO.
           05 WS-HASH-DIFF         PIC S9(15) VALUE ZERO.

      *> Stage timing
       01 WS-STAGE1-START   PIC 9(08).
       01 WS-STAGE1-END     PIC 9(08).
       01 WS-STAGE2-START   PIC 9(08).
       01 WS-STAGE2-END     PIC 9(08).
       01 WS-TOTAL-ELAPSED  PIC 9(08).

      *> Date and timestamp areas
       01 WS-PROC-DATE      PIC 9(08).
       01 WS-PROC-TIME      PIC 9(08).
       01 WS-TS-DATE        PIC X(08).
       01 WS-TS-TIME        PIC X(08).

      *> Amount areas
       01 WS-AMT-A          PIC 9(10).
       01 WS-AMT-B          PIC 9(10).
       01 WS-AMT-TEMP       PIC 9(10).
       01 WS-AMT-C          PIC 9(10).
       01 WS-AMT-FINAL      PIC 9(10).

      *> Error message areas
       01 WS-ERR-MSG        PIC X(60).
       01 WS-ERR-DETAIL     PIC X(80).

      *> Program phase
       01 WS-PGM-PHASE      PIC X(20).

       PROCEDURE DIVISION.

      *> ============================================================
      *> MAIN SECTION
      *> ============================================================
       MAIN SECTION.
       MB-PROCESS.
           PERFORM 1000-INITIALIZE

      *> ============================================
      *> STAGE 1: Match FILE-A with FILE-B -> TEMP-FILE
      *> (Original stage 1 logic preserved)
      *> ============================================
           MOVE FUNCTION CURRENT-DATE (9:8) TO WS-STAGE1-START
           DISPLAY "[" WS-TS-DATE " " WS-TS-TIME
                   "] 16-MATCHING: Stage 1 starting..."

           PERFORM 2100-OPEN-STAGE1-FILES

      *> Read first records from both files (original)
           READ FILE-A
               AT END SET WS-EOF-A-YES TO TRUE
               NOT AT END
                   ADD 1 TO WS-A-READ-COUNT
                   MOVE STD-KEY OF A-REC TO WS-KEY-A
                   MOVE STD-KEY OF A-REC TO WS-PREV-KEY-A
           END-READ.
           READ FILE-B
               AT END SET WS-EOF-B-YES TO TRUE
               NOT AT END
                   ADD 1 TO WS-B-READ-COUNT
                   MOVE STD-KEY OF B-REC TO WS-KEY-B
                   MOVE STD-KEY OF B-REC TO WS-PREV-KEY-B
           END-READ.

      *> Stage 1: 1:1 merge/match loop (original algorithm)
           PERFORM UNTIL WS-EOF-A-YES OR WS-EOF-B-YES
               IF WS-KEY-A < WS-KEY-B
      *> A record unmatched, skip it
                   ADD 1 TO WS-UNMATCH-A
                   PERFORM 5300-WRITE-ERR-UNMATCH-A
                   READ FILE-A
                       AT END SET WS-EOF-A-YES TO TRUE
                       NOT AT END
                           ADD 1 TO WS-A-READ-COUNT
                           MOVE STD-KEY OF A-REC TO WS-KEY-A
                           PERFORM 4200-CHECK-SEQ-A
                           MOVE STD-KEY OF A-REC TO WS-PREV-KEY-A
                   END-READ
               ELSE IF WS-KEY-A > WS-KEY-B
      *> B record unmatched, skip it
                   ADD 1 TO WS-UNMATCH-B
                   PERFORM 5400-WRITE-ERR-UNMATCH-B
                   READ FILE-B
                       AT END SET WS-EOF-B-YES TO TRUE
                       NOT AT END
                           ADD 1 TO WS-B-READ-COUNT
                           MOVE STD-KEY OF B-REC TO WS-KEY-B
                           PERFORM 4300-CHECK-SEQ-B
                           MOVE STD-KEY OF B-REC TO WS-PREV-KEY-B
                   END-READ
               ELSE
      *> Keys equal: match found, write A-side to temp, advance both
                   MOVE A-REC TO TEMP-REC
                   WRITE TEMP-REC
                   ADD 1 TO WS-STAGE1-COUNT
                   PERFORM 5110-ACCUMULATE-TEMP
                   READ FILE-A
                       AT END SET WS-EOF-A-YES TO TRUE
                       NOT AT END
                           ADD 1 TO WS-A-READ-COUNT
                           MOVE STD-KEY OF A-REC TO WS-KEY-A
                           PERFORM 4200-CHECK-SEQ-A
                           MOVE STD-KEY OF A-REC TO WS-PREV-KEY-A
                   END-READ
                   READ FILE-B
                       AT END SET WS-EOF-B-YES TO TRUE
                       NOT AT END
                           ADD 1 TO WS-B-READ-COUNT
                           MOVE STD-KEY OF B-REC TO WS-KEY-B
                           PERFORM 4300-CHECK-SEQ-B
                           MOVE STD-KEY OF B-REC TO WS-PREV-KEY-B
                   END-READ
               END-IF
           END-PERFORM.

      *> Drain remaining A records
           PERFORM UNTIL WS-EOF-A-YES
               ADD 1 TO WS-UNMATCH-A
               PERFORM 5300-WRITE-ERR-UNMATCH-A
               READ FILE-A
                   AT END SET WS-EOF-A-YES TO TRUE
                   NOT AT END
                       ADD 1 TO WS-A-READ-COUNT
                       MOVE STD-KEY OF A-REC TO WS-KEY-A
               END-READ
           END-PERFORM

      *> Drain remaining B records
           PERFORM UNTIL WS-EOF-B-YES
               ADD 1 TO WS-UNMATCH-B
               PERFORM 5400-WRITE-ERR-UNMATCH-B
               READ FILE-B
                   AT END SET WS-EOF-B-YES TO TRUE
                   NOT AT END
                       ADD 1 TO WS-B-READ-COUNT
                       MOVE STD-KEY OF B-REC TO WS-KEY-B
               END-READ
           END-PERFORM

           CLOSE FILE-A.
           CLOSE FILE-B.
           CLOSE TEMP-FILE.

           MOVE FUNCTION CURRENT-DATE (9:8) TO WS-STAGE1-END
           DISPLAY "[" WS-TS-DATE " " WS-TS-TIME
                   "] Stage 1 complete: " WS-STAGE1-COUNT
                   " matched records, " WS-UNMATCH-A
                   " A-unmatched, " WS-UNMATCH-B " B-unmatched"

      *> ==================================================
      *> STAGE 2: Match TEMP-FILE with FILE-C -> FINAL-OUT
      *> (Original stage 2 logic preserved)
      *> ==================================================
           MOVE FUNCTION CURRENT-DATE (9:8) TO WS-STAGE2-START
           DISPLAY "[" WS-TS-DATE " " WS-TS-TIME
                   "] 16-MATCHING: Stage 2 starting..."

           PERFORM 2200-OPEN-STAGE2-FILES

      *> Read first records
           READ TEMP-FILE
               AT END SET WS-EOF-TEMP-YES TO TRUE
               NOT AT END
                   MOVE STD-KEY OF TEMP-REC TO WS-KEY-TEMP
           END-READ.
           READ FILE-C
               AT END SET WS-EOF-C-YES TO TRUE
               NOT AT END
                   ADD 1 TO WS-C-READ-COUNT
                   MOVE STD-KEY OF C-REC TO WS-KEY-C
           END-READ.

      *> Stage 2: 1:1 merge/match loop (original algorithm)
           PERFORM UNTIL WS-EOF-TEMP-YES OR WS-EOF-C-YES
               IF WS-KEY-TEMP < WS-KEY-C
      *> Temp record unmatched, skip it
                   ADD 1 TO WS-UNMATCH-TEMP
                   PERFORM 5500-WRITE-ERR-UNMATCH-TEMP
                   READ TEMP-FILE
                       AT END SET WS-EOF-TEMP-YES TO TRUE
                       NOT AT END
                           MOVE STD-KEY OF TEMP-REC TO WS-KEY-TEMP
                   END-READ
               ELSE IF WS-KEY-TEMP > WS-KEY-C
      *> C record unmatched, skip it
                   ADD 1 TO WS-UNMATCH-C
                   PERFORM 5600-WRITE-ERR-UNMATCH-C
                   READ FILE-C
                       AT END SET WS-EOF-C-YES TO TRUE
                       NOT AT END
                           ADD 1 TO WS-C-READ-COUNT
                           MOVE STD-KEY OF C-REC TO WS-KEY-C
                   END-READ
               ELSE
      *> Keys equal: match found, write temp-side to final, advance both
                   MOVE TEMP-REC TO FINAL-REC
                   WRITE FINAL-REC
                   ADD 1 TO WS-STAGE2-COUNT
                   PERFORM 5120-ACCUMULATE-FINAL
                   READ TEMP-FILE
                       AT END SET WS-EOF-TEMP-YES TO TRUE
                       NOT AT END
                           MOVE STD-KEY OF TEMP-REC TO WS-KEY-TEMP
                   END-READ
                   READ FILE-C
                       AT END SET WS-EOF-C-YES TO TRUE
                       NOT AT END
                           ADD 1 TO WS-C-READ-COUNT
                           MOVE STD-KEY OF C-REC TO WS-KEY-C
                   END-READ
               END-IF
           END-PERFORM.

      *> Drain remaining temp records
           PERFORM UNTIL WS-EOF-TEMP-YES
               ADD 1 TO WS-UNMATCH-TEMP
               PERFORM 5500-WRITE-ERR-UNMATCH-TEMP
               READ TEMP-FILE
                   AT END SET WS-EOF-TEMP-YES TO TRUE
                   NOT AT END
                       MOVE STD-KEY OF TEMP-REC TO WS-KEY-TEMP
               END-READ
           END-PERFORM

      *> Drain remaining C records
           PERFORM UNTIL WS-EOF-C-YES
               ADD 1 TO WS-UNMATCH-C
               PERFORM 5600-WRITE-ERR-UNMATCH-C
               READ FILE-C
                   AT END SET WS-EOF-C-YES TO TRUE
                   NOT AT END
                       ADD 1 TO WS-C-READ-COUNT
                       MOVE STD-KEY OF C-REC TO WS-KEY-C
               END-READ
           END-PERFORM

           CLOSE TEMP-FILE.
           CLOSE FILE-C.
           CLOSE FINAL-OUT.
           CLOSE FILE-ERR.

           MOVE FUNCTION CURRENT-DATE (9:8) TO WS-STAGE2-END
           DISPLAY "[" WS-TS-DATE " " WS-TS-TIME
                   "] Stage 2 complete: " WS-STAGE2-COUNT
                   " final matched records"

      *> Write audit and finalize
           PERFORM 7000-AUDIT-TRAIL
           PERFORM 8000-FINALIZE

           DISPLAY '16-matching-2stage-1-1: PASS'.
           STOP RUN.
           .

      *> ============================================================
      *> 1000-INITIALIZE
      *> ============================================================
       1000-INITIALIZE.
           MOVE FUNCTION CURRENT-DATE (1:8)  TO WS-PROC-DATE
           MOVE FUNCTION CURRENT-DATE (9:8)  TO WS-PROC-TIME
           MOVE FUNCTION CURRENT-DATE (1:8)  TO WS-TS-DATE
           MOVE FUNCTION CURRENT-DATE (9:8)  TO WS-TS-TIME

           DISPLAY "============================================"
           DISPLAY "16-MATCHING-2STAGE-1-1  2-Stage Invoice Rec"
           DISPLAY "Version V2.00"
           DISPLAY "Run date: " WS-PROC-DATE " " WS-PROC-TIME
           DISPLAY "============================================"

           INITIALIZE WS-STAGE1-COUNT
           INITIALIZE WS-STAGE2-COUNT
           INITIALIZE WS-A-READ-COUNT
           INITIALIZE WS-B-READ-COUNT
           INITIALIZE WS-C-READ-COUNT
           INITIALIZE WS-UNMATCH-A
           INITIALIZE WS-UNMATCH-B
           INITIALIZE WS-UNMATCH-TEMP
           INITIALIZE WS-UNMATCH-C
           INITIALIZE WS-HASH-TOTALS
           INITIALIZE WS-WARN-COUNT
           INITIALIZE WS-FATAL-COUNT
           .

      *> ============================================================
      *> 2100-OPEN-STAGE1-FILES
      *> ============================================================
       2100-OPEN-STAGE1-FILES.
           MOVE '2100-OPEN-STAGE1' TO WS-PGM-PHASE

           OPEN INPUT FILE-A.
           IF WS-A-STATUS NOT = '00'
               STRING "FATAL: Cannot open file-a.dat, status "
                      WS-A-STATUS INTO WS-ERR-MSG
               END-STRING
               PERFORM 6000-FATAL-ERROR
           END-IF.

           OPEN INPUT FILE-B.
           IF WS-B-STATUS NOT = '00'
               STRING "FATAL: Cannot open file-b.dat, status "
                      WS-B-STATUS INTO WS-ERR-MSG
               END-STRING
               PERFORM 6000-FATAL-ERROR
           END-IF.

           OPEN OUTPUT TEMP-FILE.
           IF WS-TEMP-STATUS NOT = '00'
               STRING "FATAL: Cannot open temp.dat, status "
                      WS-TEMP-STATUS INTO WS-ERR-MSG
               END-STRING
               PERFORM 6000-FATAL-ERROR
           END-IF.

           OPEN OUTPUT FILE-ERR.
           IF WS-ERR-STATUS NOT = '00'
               STRING "FATAL: Cannot open error.dat, status "
                      WS-ERR-STATUS INTO WS-ERR-MSG
               END-STRING
               PERFORM 6000-FATAL-ERROR
           END-IF.

           PERFORM 7010-WRITE-AUDIT-HEADER
           .

      *> ============================================================
      *> 2200-OPEN-STAGE2-FILES
      *> ============================================================
       2200-OPEN-STAGE2-FILES.
           MOVE '2200-OPEN-STAGE2' TO WS-PGM-PHASE

           OPEN INPUT TEMP-FILE.
           IF WS-TEMP-STATUS NOT = '00'
               STRING "FATAL: Cannot reopen temp.dat, status "
                      WS-TEMP-STATUS INTO WS-ERR-MSG
               END-STRING
               PERFORM 6000-FATAL-ERROR
           END-IF.

           OPEN INPUT FILE-C.
           IF WS-C-STATUS NOT = '00'
               STRING "FATAL: Cannot open file-c.dat, status "
                      WS-C-STATUS INTO WS-ERR-MSG
               END-STRING
               PERFORM 6000-FATAL-ERROR
           END-IF.

           OPEN OUTPUT FINAL-OUT.
           IF WS-FINAL-STATUS NOT = '00'
               STRING "FATAL: Cannot open final.dat, status "
                      WS-FINAL-STATUS INTO WS-ERR-MSG
               END-STRING
               PERFORM 6000-FATAL-ERROR
           END-IF.

           OPEN OUTPUT AUDIT-FILE.
           IF WS-AUDIT-STATUS NOT = '00'
               DISPLAY "WARNING: Cannot open audit-report.txt, "
                       "status " WS-AUDIT-STATUS
               ADD 1 TO WS-WARN-COUNT
           END-IF.
           .

      *> ============================================================
      *> 4200-CHECK-SEQ-A — Check A key sequence
      *> ============================================================
       4200-CHECK-SEQ-A.
           IF STD-KEY OF A-REC < WS-PREV-KEY-A
               ADD 1 TO WS-SEQ-ERR-COUNT
               ADD 1 TO WS-WARN-COUNT
               DISPLAY "WARNING: A-file seq violation: "
                       WS-PREV-KEY-A " > " STD-KEY OF A-REC
           END-IF
           .

      *> ============================================================
      *> 4300-CHECK-SEQ-B — Check B key sequence
      *> ============================================================
       4300-CHECK-SEQ-B.
           IF STD-KEY OF B-REC < WS-PREV-KEY-B
               ADD 1 TO WS-SEQ-ERR-COUNT
               ADD 1 TO WS-WARN-COUNT
               DISPLAY "WARNING: B-file seq violation: "
                       WS-PREV-KEY-B " > " STD-KEY OF B-REC
           END-IF
           .

      *> ============================================================
      *> 5110-ACCUMULATE-TEMP — Accumulate temp hash
      *> ============================================================
       5110-ACCUMULATE-TEMP.
           MOVE STD-DATA-3 OF A-REC TO WS-AMT-A
           ADD WS-AMT-A TO WS-HASH-A-INPUT
           MOVE STD-DATA-3 OF TEMP-REC TO WS-AMT-TEMP
           ADD WS-AMT-TEMP TO WS-HASH-TEMP
           .

      *> ============================================================
      *> 5120-ACCUMULATE-FINAL — Accumulate final hash
      *> ============================================================
       5120-ACCUMULATE-FINAL.
           MOVE STD-DATA-3 OF FINAL-REC TO WS-AMT-FINAL
           ADD WS-AMT-FINAL TO WS-HASH-FINAL
           .

      *> ============================================================
      *> 5300-WRITE-ERR-UNMATCH-A
      *> ============================================================
       5300-WRITE-ERR-UNMATCH-A.
           MOVE 'STG1-A-UNM' TO ERR-STAGE
           MOVE STD-KEY OF A-REC TO ERR-KEY
           MOVE STD-DATA-3 OF A-REC TO WS-AMT-A
           MOVE WS-AMT-A TO ERR-AMOUNT
           WRITE ERR-REC
           .

      *> ============================================================
      *> 5400-WRITE-ERR-UNMATCH-B
      *> ============================================================
       5400-WRITE-ERR-UNMATCH-B.
           MOVE 'STG1-B-UNM' TO ERR-STAGE
           MOVE STD-KEY OF B-REC TO ERR-KEY
           MOVE STD-DATA-3 OF B-REC TO WS-AMT-B
           MOVE WS-AMT-B TO ERR-AMOUNT
           WRITE ERR-REC
           .

      *> ============================================================
      *> 5500-WRITE-ERR-UNMATCH-TEMP
      *> ============================================================
       5500-WRITE-ERR-UNMATCH-TEMP.
           MOVE 'STG2-TMP-U' TO ERR-STAGE
           MOVE STD-KEY OF TEMP-REC TO ERR-KEY
           MOVE STD-DATA-3 OF TEMP-REC TO WS-AMT-TEMP
           MOVE WS-AMT-TEMP TO ERR-AMOUNT
           WRITE ERR-REC
           .

      *> ============================================================
      *> 5600-WRITE-ERR-UNMATCH-C
      *> ============================================================
       5600-WRITE-ERR-UNMATCH-C.
           MOVE 'STG2-C-UNM' TO ERR-STAGE
           MOVE STD-KEY OF C-REC TO ERR-KEY
           MOVE STD-DATA-3 OF C-REC TO WS-AMT-C
           MOVE WS-AMT-C TO ERR-AMOUNT
           WRITE ERR-REC
           .

      *> ============================================================
      *> 6000-FATAL-ERROR
      *> ============================================================
       6000-FATAL-ERROR.
           ADD 1 TO WS-FATAL-COUNT
           DISPLAY "FATAL [" WS-TS-DATE " " WS-TS-TIME "] "
                   WS-ERR-MSG
           MOVE 16 TO RETURN-CODE
           STOP RUN
           .

      *> ============================================================
      *> 7000-AUDIT-TRAIL
      *> ============================================================
       7000-AUDIT-TRAIL.
           MOVE '7000-AUDIT-TRAIL' TO WS-PGM-PHASE
           DISPLAY "[" WS-TS-DATE " " WS-TS-TIME
                   "] 16-MATCHING: Writing audit report..."

           PERFORM 7020-WRITE-AUDIT-SUMMARY
           PERFORM 7030-WRITE-HASH-DETAIL
           PERFORM 7040-WRITE-STAGE-RECONCIL
           PERFORM 7050-WRITE-TIMING-REPORT
           PERFORM 7060-WRITE-AUDIT-FOOTER

           CLOSE AUDIT-FILE
           .

      *> ============================================================
      *> 7010-WRITE-AUDIT-HEADER
      *> ============================================================
       7010-WRITE-AUDIT-HEADER.
           MOVE SPACES TO AUDIT-REC
           STRING "================================================"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "16-MATCHING-2STAGE-1-1 AUDIT REPORT"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "Program Version: V2.00"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "Run Date: " WS-PROC-DATE " Time: " WS-PROC-TIME
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "================================================"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC
           .

      *> ============================================================
      *> 7020-WRITE-AUDIT-SUMMARY
      *> ============================================================
       7020-WRITE-AUDIT-SUMMARY.
           MOVE SPACES TO AUDIT-REC
           STRING "RECORD COUNT SUMMARY:"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "STAGE 1 (A x B):"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  A-file records read     : " WS-A-READ-COUNT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  B-file records read     : " WS-B-READ-COUNT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Stage1 matched (temp)   : " WS-STAGE1-COUNT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Unmatched A records     : " WS-UNMATCH-A
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Unmatched B records     : " WS-UNMATCH-B
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "STAGE 2 (TEMP x C):"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  C-file records read     : " WS-C-READ-COUNT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Stage2 matched (final)  : " WS-STAGE2-COUNT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Unmatched temp records  : " WS-UNMATCH-TEMP
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Unmatched C records     : " WS-UNMATCH-C
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC
           .

      *> ============================================================
      *> 7030-WRITE-HASH-DETAIL
      *> ============================================================
       7030-WRITE-HASH-DETAIL.
           MOVE SPACES TO AUDIT-REC
           STRING " "
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "HASH TOTAL RECONCILIATION:"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  A-file input hash   : " WS-HASH-A-INPUT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  B-file input hash   : " WS-HASH-B-INPUT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Temp hash (s1 match): " WS-HASH-TEMP
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  C-file input hash   : " WS-HASH-C-INPUT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Final output hash   : " WS-HASH-FINAL
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC
           .

      *> ============================================================
      *> 7040-WRITE-STAGE-RECONCIL — Inter-stage reconciliation
      *> ============================================================
       7040-WRITE-STAGE-RECONCIL.
           MOVE SPACES TO AUDIT-REC
           STRING " "
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "INTER-STAGE RECONCILIATION:"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Stage1 temp records  : " WS-STAGE1-COUNT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Stage2 final records : " WS-STAGE2-COUNT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           IF WS-STAGE1-COUNT = WS-STAGE2-COUNT
               MOVE SPACES TO AUDIT-REC
               STRING "  Stage count: VERIFIED (1:1 pass-through)"
                      INTO AUDIT-REC
               END-STRING
               WRITE AUDIT-REC
           ELSE
               MOVE SPACES TO AUDIT-REC
               STRING "  ** STAGE COUNT MISMATCH ** S1="
                      WS-STAGE1-COUNT " S2=" WS-STAGE2-COUNT
                      INTO AUDIT-REC
               END-STRING
               WRITE AUDIT-REC
           END-IF

           ADD WS-HASH-FINAL TO WS-HASH-ERR
               GIVING WS-HASH-DIFF
           SUBTRACT WS-HASH-TEMP FROM WS-HASH-DIFF
           IF WS-HASH-DIFF = 0
               MOVE SPACES TO AUDIT-REC
               STRING "  Stage hash: VERIFIED (final+err=temp)"
                      INTO AUDIT-REC
               END-STRING
               WRITE AUDIT-REC
           ELSE
               MOVE SPACES TO AUDIT-REC
               STRING "  ** STAGE HASH MISMATCH ** Diff: "
                      WS-HASH-DIFF INTO AUDIT-REC
               END-STRING
               WRITE AUDIT-REC
           END-IF
           .

      *> ============================================================
      *> 7050-WRITE-TIMING-REPORT
      *> ============================================================
       7050-WRITE-TIMING-REPORT.
           MOVE SPACES TO AUDIT-REC
           STRING " "
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "STAGE TIMING (HHMMSS format):"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Stage 1 start : " WS-STAGE1-START
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Stage 1 end   : " WS-STAGE1-END
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Stage 2 start : " WS-STAGE2-START
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Stage 2 end   : " WS-STAGE2-END
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "  Sequence errors: " WS-SEQ-ERR-COUNT
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC
           .

      *> ============================================================
      *> 7060-WRITE-AUDIT-FOOTER
      *> ============================================================
       7060-WRITE-AUDIT-FOOTER.
           MOVE SPACES TO AUDIT-REC
           STRING " "
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "================================================"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "END OF AUDIT REPORT"
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC

           MOVE SPACES TO AUDIT-REC
           STRING "Generated: " WS-PROC-DATE " " WS-PROC-TIME
                  INTO AUDIT-REC
           END-STRING
           WRITE AUDIT-REC
           .

      *> ============================================================
      *> 8000-FINALIZE
      *> ============================================================
       8000-FINALIZE.
           DISPLAY "============================================"
           DISPLAY "16-MATCHING-2STAGE-1-1  Processing Summary"
           DISPLAY "============================================"
           DISPLAY "STAGE 1: A=" WS-A-READ-COUNT
                   " B=" WS-B-READ-COUNT
           DISPLAY "  Matched=" WS-STAGE1-COUNT
                   " Unmatch-A=" WS-UNMATCH-A
                   " Unmatch-B=" WS-UNMATCH-B
           DISPLAY "STAGE 2: C=" WS-C-READ-COUNT
           DISPLAY "  Matched=" WS-STAGE2-COUNT
                   " Unmatch-Temp=" WS-UNMATCH-TEMP
                   " Unmatch-C=" WS-UNMATCH-C
           DISPLAY "--------------------------------------------"
           DISPLAY "Sequence violations : " WS-SEQ-ERR-COUNT
           DISPLAY "Warnings            : " WS-WARN-COUNT
           DISPLAY "Fatal errors        : " WS-FATAL-COUNT
           DISPLAY "Stage 1 count=" WS-STAGE1-COUNT
                   " Stage 2 count=" WS-STAGE2-COUNT
           IF WS-STAGE1-COUNT = WS-STAGE2-COUNT
               DISPLAY "Stage counts: VERIFIED"
           ELSE
               DISPLAY "STAGE COUNT MISMATCH!"
           END-IF
           DISPLAY "============================================"
           .

       END PROGRAM Match2Stage.