*COMDECK OBJDEFS                                                         OBJDEFS
                                                                         OBJDEFS
*         COMDECK OBJDEFS CONTAINS OBJECT ROUTINE ENTRY POINT            OBJDEFS
*         DESCRIPTIONS                                                   OBJDEFS
  
*         TO CHECK OUT CODE WITHOUT RE-ASSEMBLING ENTIRE CGEN PHASE,
*                APPEND DEFINITION TO THE END OF THIS (OBJDEFS) LIST, 
*                AND ALSO ASSEMBLE *TABLES*.
                                                                         OBJDEFS
* 
**        C.ACCDT - ACCEPT FROM DATE
* 
*         INPUT-
*                NONE 
* 
*         OUTPUT- 
*                DATE IN X1 FORMATTED YYMMDD RIGHT-JUSTIFIED AND
*                DISPLAY CODE ZERO FILLED 
* 
 C.ACCDT  OBJ    O=X1,S=(A0,A1,A3,A4,A5,A6,A7,X3,X4,X6,X7,B1,B2,B6,B7),S
,Q=N
          SPACE  3
**        C.ACCDY - ACCEPT FROM DAY 
* 
*         INPUT-
*                NONE 
* 
*         OUTPUT- 
*                DAY IN X1 FORMATTED YYDDD RIGHT-JUSTIFIED AND DISPLAY
*                CODE ZERO FILLED 
* 
 C.ACCDY  OBJ    O=X1,S=(A0,A2,A4,A5,A6,A7,X2,X4,X5,X6,X7,B1,B2,B3,B4,B5
,,B6,B7),SQ=N 
          SPACE  3
**        C.ACCTM - ACCEPT FROM TIME
* 
*         INPUT-
*                NONE 
* 
*         OUTPUT- 
*                TIME IN X1 FORMATTED HHMMSSNN RIGHT-JUSTIFIED AND
*                DISPLAY CODE ZERO FILLED (NN = HUNDERDTHS OF A SEC)
* 
 C.ACCTM  OBJ    O=X1,S=(A0,A1,A3,A4,A5,A6,A7,X3,X4,X6,X7,B1,B2,B4,B5,B6
,,B7),SQ=N
          SPACE  3
**        C.ACCDW- ACCEPT FROM DAY-OF-WEEK
* 
*         INPUT-
*                NONE 
* 
*         OUTPUT- 
*                DAY OF WEEK (1= MONDAY, ... , 7= SUNDAY) IN X1 
*                RIGHT-JUSTIFIED AND DISPLAY CODE ZERO FILLED 
* 
*         NOTE- 
*                THIS ROUTINE CALLS C.U08R1 AND SO IF THAT ROUTINE SHOULD 
*                CHANGE ITS LIST OF SAVED REGISTERS THIS ONE MUST ASLO
 C.ACCDW  OBJ    O=X1,S=(A0,A4,A5,A7,X4,X5,X7,B1,B2,B3,B4,B5,B6),SQ=N 
* 
          SPACE  3
**        CBACCMN - ACCEPT FROM MNEMONIC NAME 
* 
*                CALLING SEQ: 
*         SA1    MNEMONIC NAME
*         SB4    OFFSET 
*         SB5    FWA
*         SB7    LENGTH 
*                RETURNS
* 
*         DATA INTO DATA-NAME 
* 
 C.ACCMN  OBJ    I=(X1,B5,B6,B7)
          SPACE  3
* 
**        C.ADSUB - SET UP PARAMETERS ON ENTRY TO SUBROUTINE
* 
*         INPUT 
*                A1   FWA OF PARAMETER LIST  (ALREADY SET)
*                B3   FWA OF ASSOCIATION LIST 
*                B4   FWA OF INSERTION LIST 
*                B5 - ENTRY ADDRESS 
*                B6 - PROGRAM NAME ADDRESS
*                X3 - PREVIOUS BINARY LEVEL 
* 
*         OUTPUT
*                NONE 
* 
 C.ADSUB   OBJ    I=(A0,B3,B4,B5,B6,X3,X7)
          SPACE  3
* 
**        CBAD112- DISPLAY CODE ADD, SINGLE PRECISION UNSIGNED INPUT, 
*                  DOUBLE PRECISION OUTPUT
* 
*         INPUT 
*                X2  OPERAND 1
*                X4  OPERAND 2
* 
*         OUTPUT
*                X0  SUM UPPER HALF 
*                X5  SUM LOWER HALF 
* 
* 
 C.AD112  OBJ    I=(X2,X4),O=(X0,X5),S=(A0,A2,A4,A6,A7,B1,B2,B3,B4,B5,B6
,,B7,X2)
          SPACE  3
**        CBAD222 - DISPLAY CODE ADD, DOUBLE PRECISION INPUT AND OUTPUT 
* 
*         INPUT 
*                X1  OPERAND1 UPPER HALF
*                X2  OPERAND1 LOWER HALF
*                X3  OPERAND2 UPPER HALF
*                X4  OPERAND2 LOWER HALF
* 
*         OUTPUT
*                X0  SUM UPPER HALF 
*                X5  SUM LOWER HALF 
* 
 C.AD222  OBJ    I=(X1,X2,X3,X4),O=(X1,X2),S=(A0,A1,A2,A4,A6,A7,B1,B2,B3
,,B4,B5,B6,B7)
          SPACE  3
* 
**        C.ALPCM - IF ALPHABETIC  (FIELD > 1 CHAR) 
* 
*                CALLING SEQ: 
*         SB4    FWA OF FIELD 
*         SB5    LENGTH OF FIELD
*         SB6    BYTE OFFSET IN BYTES 
*         RJ     C.ALPCM
* 
*                RETURNS: 
*         B4 = 0 IF TRUE
*         B4 = 1 IF FALSE 
* 
 C.ALPCM OBJ     I=(B4,B5,B6),O=B4,S=(A0,A1,A2,A4,A5,A6,A7,X0,X1,X2,X7,B
,1,B2)
          SPACE  3
* 
**        C.ALPC1 - IF ALPHABETIC  (FIELD = 1 CHAR) 
* 
*                CALLING SEQ: 
*         SB5    BASE ADDR
*         SB6    BYTE OFFSET OF FIELD 
*         RJ     C.ALPC1
* 
*                RETURNS: 
*         B4 = 0 IF TRUE
*         B4 = 1 IF FALSE 
* 
 C.ALPC1  OBJ    I=(B5,B6),O=B4,S=(A0,A1,A2,A4,A5,A6,A7,X0,X1,X2,X5,X7,B
,1,B2,B5,B7)
          SPACE  3
* 
**        C.AN2AE -  MOVE ALPHANUMERIC ITEM TO ALPHANUMERIC-EDITED ITEM 
* 
*         INPUT 
*                B3  FWA SOURCE FIELD 
*                B4  BCP SOURCE FIELD 
*                B5  ADDRESS OF DESTINATION DESCRIPTOR
*                B7  NUMBER OF CHARACTERS IN SOURCE FIELD 
* 
*         OUTPUT
*                (NONE) 
* 
 C.AN2AE  OBJ    I=(B3,B4,B5,B7),SQ=Y 
          SPACE  3
* 
**        C.AN2EC - MOVE CHARS FROM CORE TO ECS 
* 
*         INPUT 
*                B3= FWA OF RECEIVING FIELD 
*                B4= BCP OF RECEIVING FIELD 
*                B5= FWA OF SOURCE FIELD
*                B6= BCP OF SOURCE FIELD
*                B7= NUMBER OF CHARS TO MOVE
*                X2= NUMBER OF BLANKS TO APPEND IF NEGATIVE 
*                  = NUMBER OF BLANKS TO PREFIX IF POSITIVE 
* 
*         OUTPUT
*                NONE 
* 
 C.AN2EC  OBJ    I=(B3,B4,B5,B6,B7,X2),SQ=Y 
          SPACE  3
* 
**        C.AOPTN -  CONVERT BLANKS TO ZEROS
* 
*         INPUT 
*                X1   10 CHARACTERS 
* 
*         OUTPUT
*                X1   10 CHARACTERS 
* 
 C.AOPTN  OBJ    I=(X1),O=(X1),S=(X2,X3,X4,X5,X6,X7,A0,A1,A2,A3,A4,A5,A6
,,A7,B1,B2,B3,B4,B5),SQ=N 
          SPACE  3
* 
          SPACE  3
* 
**        C.BCDCM - COLLATED COMPARES, FOR DATA ITEM VS DATA ITEM 
* 
*                CALLING SEQUENCE:  
*         SX1    BYTE OFFSET OF A 
*         SX2    BYTE OFFSET OF B 
*         SB3    BASE ADDR OF A 
*         SB4    BASE ADDR OF B 
*         SB5    LENGTH OF A (BYTES)
*         SB6    LENGTH OF B (BYTES)
*         RJ     C.BCDCM
* 
*                RETURNS: 
*         B3 = 0 FOR A = B
*         B3 > 0 FOR A > B
*         B3 < 0 FOR A < B
* 
 CMUB     IFEQ   OP.BDP,OP.NO      NO CMU 
 C.BCDCM  OBJ    I=(X1,X2,B3,B4,B5,B6),O=B3,S=(A0,A1,A6,A7,B1,B2) 
 CMUB     ELSE               YES CMU
 C.BCDCM  OBJ    I=(X1,X2,B3,B4,B5,B6),O=B3,SQ=Y,S=(A1,A2,A4,A5,A7,B1,B2
,)
 CMUB     ENDIF 
          SPACE  3
* 
**        C.CALL - CALL 
* 
*         INPUT 
*                B3 - ADDRESS OF NAME OF CALLED ROUTINE 
*                B4 - BCP OF NAME OF CALLED ROUTINE 
*                B5 - LENGTH OF NAME
*                B7 - PARAMETER LIST ADDRESS
*         OUTPUT
*         B6 - OVERFLOW FLAG
 C.CALL   OBJ    I=(B3,B4,B7,B5),O=B6 
          SPACE  3
* 
**        C.CLOXX - CLOSE FILE (XX IS FILE ORG) 
* 
*                CALLING SEQ: 
*         SA0    FIT ADDR 
*         SB3    REWIND OPTION
*         SB6    RETURN 
*         EQ     C.CLOXX
* 
*                RETURNS: 
*         NOTHING 
* 
*                CALLS FOR EVERY FO MUST STAY IN ORDER
* 
 C.CLOAK  OBJ    I=(A0,B3),SQ=Y,BREG=6
 C.CLODA  OBJ    I=(A0,B3),SQ=Y,BREG=6
 C.CLOIS  OBJ    I=(A0,B3),SQ=Y,BREG=6
 C.CLORL  OBJ    I=(A0,B3),SQ=Y,BREG=6
 C.CLOSQ  OBJ    I=(A0,B3),SQ=Y,BREG=6
 C.CLOWA  OBJ    I=(A0,B3),SQ=Y,BREG=6
          SPACE  3
* 
**        C.CLOSR - CLOSE REEL/UNIT 
* 
*         INPUTS
*                A0 = FIT 
*                B3 = REWIND OPTION 
*                B6 = RETURN
* 
*         OUTPUTS - NONE
* 
 C.CLOSR  OBJ    I=(A0,B3),SQ=Y,BREG=6,S=A0 
          SPACE  3
* 
**        C.CLRDC - CLEAR SUBPROGRAM DECLARATIVE POINTER VECTOR ADDRESS 
* 
*         INPUTS - NONE 
* 
*         OUTPUTS - NONE
* 
 C.CLRDC  OBJ    SQ=N,S=(X2,X3,X4,A0,A2,A3,A4,B1,B2,B3,B4,B5,B6)
          SPACE  3
* 
**        C.CMUMV - MOVE CHAR STRING AND BLANK FILL VIA CMU 
* 
*         INPUT 
*                X3 = INDIRECT MOVE DESCRIPTOR WORD SKELETON
*                X4 = SUBSCRIPT FOR RECEIVING FIELD 
*                X5 = SUBSCRIPT FOR SOURCE FIELD
*                X2 = NUMBER OF SPACES TO PREFIX IF POSITIVE
*                   = NUMBER OF SPACES TO APPEND IF NEGATIVE
* 
*         OUTPUT
*                NONE 
 C.CMUMV  OBJ    I=(X3,X5,X4,X2),S=(A0,A2,A5,B2,B3,B4,B5,B6,B7),SQ=Y
          SPACE 3 
* 
**        C.CNCL - CANCEL 
* 
*         INPUT 
*                B3 - ADDRESS OF NAME OF CANCELLED ROUTINE
*                B4 - BCP OF NNME OF CANCELLED ROUTINE
*                B5 - LENGTH OF NAME
 C.CNCL   OBJ    I=(B3,B4,B5) 
          SPACE  3
* 
**        C.DELXX - DELETE RECORD FROM FILE (XX IS THE FILE ORG)
* 
*                CALLING SEQ: 
*         SA0    FIT ADDRESS
*         MX4    1 IF INVALID KEY GIVEN, 0 IF NOT 
*         SB6    RETURN 
*         EQ     C.DELXX
* 
*                RETURNS: 
*         NOTHING 
* 
*         CALLS FOR EVERY FO MUST STAY IN ORDER 
* 
 C.DELAK  OBJ    I=(A0,X4,X1),O=B3,SQ=Y,BREG=6
 C.DELDA  OBJ    I=(A0,X4,X1),O=B3,SQ=Y,BREG=6
 C.DELIS  OBJ    I=(A0,X4,X1),O=B3,SQ=Y,BREG=6
 C.DELRL  OBJ    I=(A0,X4,X1),O=B3,SQ=Y,BREG=6
          SPACE  3
* 
**        C.DMEND - INTERFACE TO CDCS -TERMINATE- 
* 
*         INPUT 
*                NONE 
* 
*         OUTPUT
*                NONE 
* 
 C.DMEND  OBJ    SQ=Y 
          SPACE  3
* 
**        C.DMINV - INTERFACE TO CDCS -INVOKE- FROM MAIN COBOL PROGRAM
**        C.DMSUB - INTERFACE TO CDCS -INVOKE- FROM NON-MAIN COBOL SUB- 
**                  COMPILE 
* 
*         INPUT 
*                B4 = RELATIONS/QUALIFIERS TABLE ADDRESS
*                     FOR EACH RELATION 
*                       WORD 1 - NUMBER +1 OF RELATION QUALIFIERS, RELA-
*                                TION ORDINAL 
*                       1 WORD/QUALIFIER - QUALIFIER ADDRESS
*                     ZERO WORD ENDS TABLE
*                B5 = RELATIONS/AREAS TABLE ADDRESS 
*                     FOR EACH RELATION 
*                       WORD 1 - NUMBER OF AREAS IN RELATION, RELATION
*                                ORDINAL
*                       1 WORD/AREA - AREA FIT ADDRESS
*                       ZERO WORD 
*                     ZERO WORD ENDS TABLE
*                B6 = PARAMETER BLOCK ADDRESS 
*                     WORD 0 - SUB-SCHEMA NAME
*                     WORD 1 - NAME OF FILE CONTAINING SUB-SCHEMA 
*                     WORD 2 - PROGRAM ID 
*                     WORD 3 - TIME/DATE OF SUB-SCHEMA COMPILATION
*                     WORD 4 THRU N - CDCS -FILE USAGE- TABLE (1 WORD/
*                      CDCS I/O FILE, ENDING WITH 0 WORD), INDICATIVE 
*                      OF I/O OPERATIONS TO BE PERFORMED ON FILE
*                X6 = =XDM$OP2 IF PROGRAM DOES AN -OPEN OUTPUT- ON A
*                      SUB-SCHEMA-DESCRIBED MIP FILE
*                   = 0 OTHERWISE 
* 
*         OUTPUT
*                NONE 
* 
 C.DMINV  OBJ    I=(B6,X6,B4,B5),SQ=Y 
 C.DMSUB  OBJ    I=(B6,X6,B4,B5),SQ=Y 
          SPACE  3
* 
**        C.DMRN - INTERFACE TO CDCS RELATION READ, SEQUENTIAL MODE 
*                   (PARALLELS -C.RDNXX-) 
**        C.DMRR - INTERFACE TO CDCS RELATION READ, RANDOM MODE WITH
*                   -ROOT AREA- HAVING NO INDEX FILE (PARALLELS 
*                   -C.RDRXX-)
**        C.DMRS - INTERFACE TO CDCS RELATION READ, RANDOM MODE WITH
*                   -ROOT AREA- HAVING ALTERNATE KEYS (PARALLELS
*                   -C.RDSXX-)
*         INPUT 
*                A0 - RELATION ORDINAL
*                X1 - MEANINGLESS, C.DMRR ONLY
*                B3 - KEY ORDINAL, C.DMRS ONLY
*                X4 - BIT 59 = 1 IF -AT END- OR -INVALID KEY-, ELSE 0 
*                B6 - RETURN ADDRESS
* 
*         OUTPUT
*                B3 - 1, IF -AT END- OR -INVALID KEY-, ELSE 0 
* 
* 
 C.DMRN   OBJ    I=(A0,X4),O=B3,SQ=Y,BREG=6 
 C.DMRR   OBJ    I=(A0,X4,X1),O=B3,SQ=Y,BREG=6
 C.DMRS   OBJ    I=(A0,X4,B3),O=B3,SQ=Y,BREG=6
          SPACE  3
* 
**        C.DSPLY - DISPLAY 
* 
*                CALLING SEQ: 
*         SA1    MENMONIC NAME
*         SB4    NOADV
*         SB5    OFFSET 
*         SB6    FWA
*         SB7    LENGTH 
* 
*         RETURNS:  
*         NOTHING 
* 
 C.DSPLY  OBJ    I=(X1,B4,B5,B6,B7) 
          SPACE  3
* 
**        C.DTOD - DOUBLE ** DOUBLE 
* 
*         INPUT 
*                X1   BASE (UPPER HALF) 
*                X2   BASE (LOWER HALF) 
*                X3   EXPONENT (UPPER HALF) 
*                X4   EXPONENT (LOWER HALF) 
* 
*         OUTPUT
*                X5   RESULT (UPPER HALF) 
*                X0   RESULT (LOWER HALF) 
*                B3   ERROR FLAG
* 
 C.DTOD   OBJ    I=(X1,X2,X3,X4),O=(X5,X0,B3) 
          SPACE  3
* 
**        C.DTOI - DOUBLE ** INTEGER
* 
*         INPUT 
*                X1   BASE (UPPER HALF) 
*                X2   BASE (LOWER HALF) 
*                X3   EXPONENT
* 
*         OUTPUT
*                X5   RESULT (UPPER HALF) 
*                X0   RESULT (LOWER HALF) 
*                B3   ERROR FLAG
* 
 C.DTOI   OBJ    I=(X1,X2,X3),O=(X5,X0,B3)
          SPACE  3
* 
**        C.DTOR - DOUBLE ** REAL 
* 
*         INPUT 
*                X1   BASE (LOWER HALF) 
*                X2   BASE (UPPER HALF) 
*                X3   EXPONENT
* 
*         OUTPUT
*                X5    RESULT (UPPER HALF)
*                X0    RESULT (LOWER HALF)
*                B3   ERROR FLAG
* 
 C.DTOR   OBJ    I=(X1,X2,X3),O=(X5,X0,B3)
          SPACE  3
* 
**        C.EC2AN - MOVE CHARS FROM ECS TO CORE 
* 
*         INPUT 
*                B3= FWA OF RECEIVING FIELD 
*                B4= BCP OF RECEIVING FIELD 
*                B5= FWA OF SOURCE FIELD
*                B6= BCP OF SOURCE FIELD
*                B7= NUMBER OF CHARS TO MOVE
*                X2= NUMBER OF BLANKS TO APPEND IF NEGATIVE 
*                  = NUMBER OF BLANKS TO PREFIX IF POSITIVE 
* 
*         OUTPUT
*                NONE 
* 
 C.EC2AN  OBJ    I=(B3,B4,B5,B6,B7,X2),SQ=Y 
          SPACE  3
* 
**        C.EC2EC - MOVE CHARS FROM ECS TO ECS
* 
*         INPUT 
*                B3= FWA OF RECEIVING FIELD 
*                B4= BCP OF RECEIVING FIELD 
*                B5= FWA OF SOURCE FIELD
*                B6= BCP OF SOURCE FIELD
*                B7= NUMBER OF CHARS TO MOVE
*                X2= NUMBER OF BLANKS TO APPEND IF NEGATIVE 
*                  = NUMBER OF BLANKS TO PREFIX IF POSITIVE 
* 
*         OUTPUT
*                NONE 
* 
 C.EC2EC  OBJ    I=(B3,B4,B5,B6,B7,X2),SQ=Y 
          SPACE  3
* 
**        C.EDIT -  MOVE AN ITEM TO AN EDITED FIELD 
* 
*         INPUT 
*                X2  SOURCE SIGN TYPE,BCP, LENGTH 
*                B3  ADDRESS DESTINATION DESCRIPTOR 
*                B4  ADDRESS SOURCE 
*         OUTPUT
*                (NO REGISTER OUTPUT) 
 C.EDIT   OBJ    I=(B4,B3,X2) 
          SPACE  3
* 
**        C.EDITA - MOVE LBZ ITEM TO AN EDITED FIELD
* 
*         INPUT 
*                B3  ADDRESS DESTINATION DESCRIPTOR 
*                B4  ADDRESS SOURCE 
*                X4  SOURCE SIGN TYPE, BCP, LENGTH
* 
*         OUTPUT
*                (NO REGISTER OUTPUT) 
* 
 C.EDITA  OBJ    I=(B4,B3,X4) 
          SPACE  3
* 
**        C.EDITS -  MOVE ITEM WITH REGISTER SIGN TO EDITED FIELD 
* 
*         INPUT 
*                X2  45/4,4/SOURCE BCP,11/SOURCE LENGTH 
*                B3  ADDRESS DESTINATION DESCRIPTOR 
*                B4 ADDRESS SOURCE
*                X0  SIGN  (BIT 59 = 1 IFF SOURCE IS NEGATIVE)
* 
*         OUTPUT
*                (NO REGISTER OUTPUT) 
 C.EDITS  OBJ    I=(B4,B3,X2,X0)
          SPACE  3
* 
**        C.EDITZ -  MOVE AN ITEM TO PIC ZZZ
* 
*         INPUT 
*                X0  NEGATIVE MASK INDICATING RELEVANT DIGITS 
*                      (CREATED WITH  MX0 N;  N\12) 
*                X1  SOURCE DIGITS,  RIGHT-JUSTIFIED,  GARBAGE-FILLED 
*                B7  RETURN ADDRESS 
* 
*         OUTPUT
*                X6  RESULT,  RIGHT-JUSTIFIED,  BLANK-FILLED
* 
 C.EDITZ  OBJ    I=(X0,X1),O=(X6),BREG=7,S=(X3,X4,X5,X7,A0,A3,A4,A5,A6,A
,7,B1,B2,B3,B4,B5,B7),SQ=N
          SPACE  3
* 
**        C.ENTRY - STACK PROGRAM NAME FOR TRACE BACK 
* 
*         INPUT 
*                B3 - ENTRY ADDRESS 
*                B4 - PROGRAME NAME LOCATION
* 
 C.ENTRY  OBJ    I=(B3,B4)
* 
**        C.EXITP   - UNSTACK PROGRAM NAME
* 
 C.EXITP  OBJ 
          SPACE  3
*                                                                       133000
**        C.GTERR - UNFILLED EMPTY GO TO                                134000
*                                                                       135000
*                CALLING SEQ:                                           136000
*         RJ     C.GTERR                                                137000
*                                                                       138000
*                RETURNS:                                               139000
*         NOTHING                                                       140000
*                                                                       141000
 C.GTERR  OBJ                                                           142000
          SPACE  3                                                      143000
* 
**        C.INIT - INITIALIZE OBJECT TIME ROUTINES
* 
*                CALLING SEQ: 
*         RJ     C.INIT 
* 
*         INPUT 
*                X1 = CONTROL CARD PARAMETERS USED BY OBJ ROUTINES
*                X2 = DATE PROGRAM COMPILED 
*                X3 = LIBRARY NAME WHICH COBOL5 IS ON 
*                B4 - PROGRAM NAME ADDRESS
* 
*         NO RETURNS OR SAVES 
* 
 C.INIT   OBJ    I=(X1,X3,B4,X2)
          SPACE  4
* 
*         C.INSPF - INSPECT FAST
* 
*         INPUT 
*                B3 = RESULT ADDRESS
*                B4 = RESULT BCP (+ SUBSC CHAR OFFSET IF SUBSCRIPTED) 
*                B5 = PARAMETER LIST ADDRESS
*                B6 = LAST PARAMETER ADDRESS
*                B7 = RESULT LENGTH 
* 
*         PARAMETER LIST
* 
*         VFD    6/TYPE,18/LENGTH,18/ADDR,18/BCP
* 
*      TYPE HAS THE FOLLOWING VALUES
*      NOTE THAT 60B IS ALSO THE STRING/UNSTRING IDENTIFIER DELIM PARAM 
*         00B = CHARS SEARCH SPECIFICATION (+ ITEM TO REPACE BY)
*         01B =     CHARS SEARCH SPEC (+ SIGNED LEFT NUMERIC REPL. ITEM)
*         02B =     CHARS SEARCH SPEC (+ SIGNED RIGHT NUMERIC REPL ITEM)
*         10B = ALL SEARCH SPECIFICATION (+ ITEM TO SEARCH FOR) 
*         11B =     ALL SEARCH SPEC (+ SIGNED LEFT NUMERIC SEARCH ITEM) 
*         12B =     ALL SEARCH SPEC (+ SIGNED RIGHT NUMERIC SEARCH ITEM)
*         20B = LEADING SEARCH SPECIFICATION (+ ITEM TO SEARCH FOR) 
*         21B =     LEADING SEARCH SPEC (+ SIGNED LEFT NUMERIC ITEM)
*         22B =     LEADING SEARCH SPEC (+ SIGNED RIGHT NUMERIC ITEM) 
*         30B = FIRST SEARCH SPECIFICATION (+ ITEM TO SEARCH FOR) 
*         31B =     FIRST SEARCH SPEC (+ SIGNED LEFT NUMERIC SEARCH ITM)
*         32B =     FIRST SEARCH SPEC (+ SIGNED RIGHT NUMERIC SRCH ITEM)
*         40B = ITEM TO REPLACE BY (+ OPERAND TO REPLACE BY)
*         41B =     ITEM TO REPLACE BY (+ SIGNED LEFT NUMERIC REPL ITEM)
*         42B =     ITEM TO REPLACE BY (+ SIGNED RIGHT NUMERIC REPL ITM)
*         50B = TALLYING SUBROUTINE ADDRESS (IF LONG INSPECT TALLYING)
*         51B = TALLY/REPLACE PARAMETER GROUP COUNT 
*         60B = BEFORE SEARCH BOUNDARY (+ BOUNDARY ITEM)
*         61B =     BEFORE SEARCH BOUNDARY (+ SIGNED LEFT NUMERIC BOUND)
*         62B =     BEFORE SEARCH BOUNDARY (+ SIGNED LEFT NUMERIC BND)
*         70B = AFTER SEARCH BOUNDARY (+ BOUNDARY ITEM) 
*         71B =     AFTER SEARCH BOUNDARY (+ SIGNED LEFT NUMERIC BOUND) 
*         72B =     AFTER SEARCH BOUNDARY (+ SIGNED RIGHT NUMERIC BOUND)
* 
*      TALLY PARAMETER GROUP IS CONSTRUCTED AS FOLLOWS
*      (THIS GROUP IS REPEATED FOR EACH ITEM TO BE SEARCHED FOR)
* 
*         SEARCH SPECIFICATION
*        [BOUNDARY     ]               * IF BEFORE/AFTER
* 
*      REPLACE PARAMETER GROUP IS CONSTRUCTED AS FOLLOWS
*      (THIS GROUP IS REPEATED FOR EACH ITEM TO BE SEARCHED FOR)
* 
*         SEARCH SPECIFICATION
*        [BOUNDARY     ]               * IF BEFORE/AFTER
*        [REPLACE ITEM ]               * IF NOT CHAR SPECIFICATION
* 
*         OUTPUT
*                X2 = TALLY VALUE TO ADD TO TALLY ITEM
* 
 C.INSRF  OBJ    I=(B3,B4,B5,B6,B7) 
 C.INSPF  OBJ    I=(B3,B4,B5,B6,B7),O=X2
          SPACE  3
* 
*         C.INSPS - INSPECT TALLYING
*         C.INSRS - INSPECT REPLACING 
* 
*         INPUT 
*                X0  SEARCH SPECIFICATION COUNT 
*                B3  RESULT ADDRESS 
*                B4  RESULT OFFSET
*                B5  PARAMETER LIST ADDRESS 
*                B6  LAST PARAMETER ADDRESS 
*                B7  RESULT LENGTH
 C.INSPS  OBJ    I=(X0,B3,B4,B5,B6,B7)
 C.INSRS  OBJ    I=(X0,B3,B4,B5,B6,B7)
          SPACE  3
* 
*         C.ITDMP - INITIALIZE TERMINAL DUMP
* 
*         INPUT 
*                B3 - MAIN PROGRAM ENTRY POINT
*                B4 - PROGRAM NAME ADDRESS
* 
 C.ITDMP  OBJ    I=(B3,B4)
          SPACE  3
* 
**        C.ITOD - INTEGER ** DOUBLE
* 
*         INPUT 
*                X1   BASE
*                X3   EXPONENT (UPPER HALF) 
*                X4   EXPONENT (LOWER HALF) 
* 
*         OUTPUT
*                X5   RESULT (UPPER HALF) 
*                X0   RESULT (LOWER HALF) 
*                B3   ERROR FLAG
 C.ITOD   OBJ    I=(X1,X3,X4),O=(X5,X0,B3)
          SPACE  3
* 
**        C.ITOI - INTEGER ** INTEGER 
* 
*         INPUT 
*                X1   BASE
*                X3   EXPONENT
* 
*         OUTPUT
*                X5   RESULT
*                B3   ERROR FLAG
* 
 C.ITOI   OBJ    I=(X1,X3),O=(X5,B3)
          SPACE  3
* 
**        C.ITOR - INTEGER ** REAL
* 
*         INPUT 
*                X1   BASE
*                X3   EXPONENT
* 
*         OUTPUT
*                X5   RESULT
*                B3   ERROR FLAG
* 
 C.ITOR   OBJ    I=(X1,X3),O=(X5,B3)
          SPACE  3
* 
**        C.KYDEF - CALLED TO DEFINE MULTIPLE KEYS FOR MIP FILES
* 
*         THE ONLY INPUT IS THE FIT ADDR IN A0
* 
*         NO OUTPUT 
* 
 C.KYDEF  OBJ    I=(A0),SQ=N
          SPACE  3
* 
**        C.LABLI - LABEL PROCESS INITIALIZATION
* 
*         INPUT 
*                A0 - FIT ADDRESS 
*                B6 - RETURN ADDRESS
* 
*         OUTPUTS 
*                NONE 
* 
 C.LABLI  OBJ    I=A0,SQ=N,S=A0 
          SPACE  3
* 
**        C.LINAA - LINAGE WRITE AFTER ADVANCING
* 
*         INPUTS
*                A0 - FIT ADDRESS 
*                B3 - 1 IF MENMONIC, 0 IF INTEGER 
*                B6 - RETURN ADDRESS
*                X1 - ADVANCING COUNT OR MNEMONIC 
 CDCS     IFNE   OP.DCS,OP.NO 
*                X7 - RECORD ORDINAL (CDCS I/O) 
 CDCS     ENDIF 
*                X3 - RECORD LENGTH 
* 
*         OUTPUTS 
  
*                B3 - ZERO IF NO EOF, 1 IF AN EOP EXISTS
* 
 CDCS     IFNE   OP.DCS,OP.NO 
 C.LINAA  OBJ    I=(A0,B3,X1,X3,X7),O=B3,SQ=Y,BREG=6
 CDCS     ELSE   1
 C.LINAA  OBJ    I=(A0,B3,X1,X3),O=B3,SQ=Y,BREG=6 
          SPACE  3
* 
**        C.LINBA - LINAGE WRITE BEFORE ADVANCING 
* 
*         INPUTS
*                A0 - FIT ADDRESS 
*                B3 - 1 IF MENMONIC, 0 IF INTEGER 
*                B6 - RETURN ADDRESS
*                X1 - ADVANCING COUNT OR MNEMONIC 
 CDCS     IFNE   OP.DCS,OP.NO 
*                X7 - RECORD ORDINAL (CDCS I/O) 
 CDCS     ENDIF 
*                X3 - RECORD LENGTH 
* 
*         OUTPUTS 
*                B3 - ZERO IF NO EOF, 1 IF AN EOP EXISTS
* 
 CDCS     IFNE   OP.DCS,OP.NO 
 C.LINBA  OBJ    I=(A0,B3,X1,X3,X7),O=B3,SQ=Y,BREG=6
 CDCS     ELSE   1
 C.LINBA  OBJ    I=(A0,B3,X1,X3),O=B3,SQ=Y,BREG=6 
          SPACE  3
* 
**        C.LINOP - LINAGE OPEN 
* 
*         INPUT - A0 HAS FIT FROM PREVIOUS OPEN CALL
* 
 C.LINOP  OBJ    SQ=Y,BREG=6
          SPACE  3
* 
**        C.LITCM - COLLATED COMPARES - UNPOOLED "ALL" LITERAL VS D.I.
* 
*                CALLING SEQ: 
*         SX1    BYTE OFFSET OF A 
*         SX2    BYTE OFFSET OF B 
*         SB3    BASE ADDR OF A 
*         SB4    BASE ADDR OF B 
*         SB5    LENGTH OF A (BYTES)
*         SB6    LENGTH OF B (BYTES)
*         SB7    0;  A IS THE LITERAL 
*                1;  B IS THE LITERAL 
*         RJ     C.LITCM
* 
*                RETURNS: 
*         B3 = 0 FOR A = B
*         B3 > 0 FOR A > B
*         B3 < 0 FOR A < B
* 
 C.LITCM  OBJ    I=(X1,X2,B3,B4,B5,B6,B7),O=B3,SQ=Y,S=(B1,B2,A0,A1) 
          SPACE  3
* 
*         C.MERGI - INITIALIZE AND PERFORM MERGE (VIA SORT/MERGE 5) 
* 
*         INPUT 
*                A0=MERGE FILE (SD) FIT ADDRESS 
*                X0=ADDRESS OF KEY AND FILE INFO
*                X1=0 IF NO -COLLATING SEQUENCE- OPTION 
*                  =BITS 29-0 - COLLATING SEQUENCE NUMBER, AND
*                   BITS 59-30 - ADDRESS OF COLLATING SEQUENCE, IF
*                                USER-DEFINED 
*                B3=0 
*                X3=ADDRESS OF -USING- AREA 
*                B4=0 IF -GIVING- 
*                  =1 IF -OUTPUT PROCEDURE- 
*                X4=ADDRESS OF -GIVING- AREA OR -OUTPUT PROCEDURE- AREA 
*                   (NOTE OBJECT ROUTINE) 
*                X5=SMCONM (ENTRY IN SORT/MERGE)
*                B7=RETURN ADDRESS
*                RJ  =XC.MERGI
* 
*         OUTPUT - NOTHING
* 
 C.MERGI  OBJ    I=(A0,X0,X1,B3,X3,B4,X4,X5,B7),SQ=Y
          SPACE  3
* 
**        C.MOVE - MOVE CHARACTER STRING AND BLANK FILL 
* 
*         INPUT 
*                B3= FWA OF RECEIVING FIELD 
*                B4= BCP OF RECEIVING FIELD 
*                B5= FWA OF SOURCE FIELD
*                B6= BCP OF SOURCE FIELD
*                B7= NUMBER OF CHARS TO MOVE
*                X2= NUMBER OF BLANKS TO APPEND IF NEGATIVE 
*                  = NUMBER OF BLANKS TO PREFIX IF POSITIVE 
* 
*         OUTPUT
*                B3= ADDRESS OF NEXT WORD TO STORE INTO 
*                B4= BCP OF NEXT FIELD TO STORE INTO
* 
*         NOTE- 
*                THIS ENTRY POINT INTO CBMOVE IS USED WHEN YOU WANT 
*                B3 AND B4 TO BE UPDATED (I.E. YOU REFERENCE THEM IN
*                SUBSEQUENT CODE) 
*                THIS ENTRY POINT CAN BE USED EVEN IF YOU DONT
*                REFERNECE B3 AND B4 LATER BUT YOU TAKE THE CHANCE
*                OF THE ASSEMBLER GETTING MAD AT YOU
* 
 C.MOVE   OBJ    I=(B3,B4,B5,B6,B7,X2),O=(B3,B4),S=(A0,X0,A4,A2),SQ=Y 
          SPACE  3
* 
**        C.MOVN - MOVE CHAR STRING AND BLANK FILL
* 
*         INPUT 
*                B3= FWA OF RECEIVING FIELD 
*                B4= BCP OF RECEIVING FIELD 
*                B5= FWA OF SOURCE FIELD
*                B6= BCP OF SOURCE FIELD
*                B7= NUMBER OF CHARS TO MOVE
*                X2= NUMBER OF BLANKS TO APPEND IF NEGATIVE 
*                  = NUMBER OF BLANKS TO PREFIX IF POSITIVE 
* 
*         OUTPUT
*                NONE 
* 
*         NOTE- 
*                THIS ENTRY POINT INTO CBMOVE IS USED WHEN YOU DON"T
*                CARE IF B3 AND B4 ARE UPDATED.  IT IS EQUATED TO C.MOVE
*                AND EXISTS ONLY TO KEEP THE ASSEMBLER HAPPY. 
 C.MOVN   OBJ    I=(B3,B4,B5,B6,B7,X2),S=(A0,X0,A4,A2),SQ=Y 
* 
          SPACE  3
* 
**        C.MOVRC - READ INTO MOVE RECORD PROCESSOR 
* 
*         GENERATES 
*           SB3  FWA    OF RECEIVER 
*           SB4  BCP
*           SB7  LENGTH OF RECEIVER 
* 
*         NO OUTPUTS
* 
 C.MOVRC  OBJ    I=(B3,B4,B7),SQ=Y
          SPACE  3
* 
**        C.MOVRE - READ INTO MOVE TO ECS PROCESSOR 
* 
*         GENERATES - SAME AS C.MOVRC 
* 
 C.MOVRE  OBJ    I=(B3,B4,B7),SQ=Y
          SPACE  3
* 
**        C.MOVS - BLANK FILL A FIELD 
* 
*         INPUT 
*                B3= FWA OF RECEIVING FIELD 
*                B4= BCP OF RECEIVING FIELD 
*                B7= 0
*                X2= NUMBER OF BLANKS TO MOVE 
* 
*         OUTPUT
*                NONE 
* 
*         NOTE- 
*                THIS ENTRY POINT INTO CBMOVE IS USED WHN YOU WANT TO 
*                FILL A FIELD WITH BLANKS.  IT IS EQUATED TO C.MOVE 
*                AND EXISTS ONLY TO KEEP THE ASSEMBLER HAPPY
* 
 C.MOVS   OBJ    I=(B3,B4,B7,X2),S=(A0,X0,A4,A2),SQ=Y 
          SPACE  3
* 
**        C.MOVX - MOVE CHAR STRING FOR SA2RA 
* 
*         INPUT 
*                B3= FWA OF RECEIVING FIELD 
*                B4= BCP OF RECEIVING FIELD 
*                B5= FWA OF SOURCE FIELD
*                B6= BCP OF SOURCE FIELD
*                B7= NUMBER OF CHARS TO MOVE
*                X2= NUMBER OF BLANKS TO APPEND IF NEGATIVE 
*                  = NUMBER OF BLANKS TO PREFIX IF POSITIVE 
* 
*         OUTPUT
*                NONE 
* 
*         NOTE- 
*         THIS ENTRY POINT INTO CBMOVE IS USED ONLY BY SA2RA TO MOVE
*         CHARS INTO C.BUFF.  IT SHOULD BE REMOVED WHIN SA2RA IS REWRITTEN. 
*         IT IS NECESSARY SO THE ASSEMBLER WILL NOT KNOW THAT SA2RA 
*         DOES A STORE
 C.MOVX   OBJ    I=(B3,B4,B5,B6,B7,X2),S=(A0,X0,A4,A2),SQ=N 
          SPACE  3
* 
**        C.MSG  I OUTPUT MESSAGE TO DAYFILE
* 
*         INPUT 
*                X1  MESSAGE NUMBER 
*                X2= 0 IF NO INSERTIONS 
*                  " 0 IF INSERTIONS
*                X3= 0 IF LINE NUMBER IN LOWER HALF OF RJ 
*                  " 0 IF LOCATION CONTAINING LINE NUMBER 
*                X6= 0 RETURN TO CALLER 
*                  " 0 ABORT
* 
 C.MSG    OBJ    I=(X1,X2,X3,X6),S=(X2,X3,B2,B3,B4,A2,A3) 
          SPACE  3
* 
**        C.MVHL - MOVE HIGH-VALUES OR LOW-VALUES 
* 
*         INPUT 
*                B3= FWA OF RECEIVING FIELD 
*                B4= BCP OF RECEIVING FIELD 
*                B7= NUMBER OF CHARS TO MOVE
*                X2= FULL WORD (10 CHARS) OF HIGH-VALUES OR LOW-VALUES
* 
*         OUTPUT- NONE
* 
 C.MVHL   OBJ    I=(B3,B4,B7,X2),S=(A2,A3,X3,A5,X5,A6,X6),SQ=Y
          SPACE  3
* 
**        C.NR2RN -  SUBSCRIPTED NUMERIC TO REGISTER NUMERIC
* 
*         INPUT 
*                X0   DESCRIPTOR   (SEE OBJECT ROUTINE) 
*                X1 = CHARACTER OFFSET FROM SOURCE ADDRESS
*                       (0 @ X1 < 2'18) 
*                B3   SOURCE ADDRESS
* 
*         OUTPUT
*                X1   (SIGNED) MOST SIGNIFICANT DIGITS OF RESULT
*                X2   (SIGNED) LEAST SIGNIFICANT DIGITS OF RESULT 
* 
 C.ND2RN  OBJ    I=(X0,X1,B3),O=(X1,X2),S=(X5,X6,X7,A5,A6,A7,B2),SQ=N 
          SPACE  3
* 
**        C.NUMR - IF NUMERIC WITHOUT A-OPTION
* 
*                CALLING SEQ: 
*         SB4    BYTE OFFSET OF FIELD 
*         SB5    FWA FIELD
*         SB6    CHAR. LENGTH OF FLD
*         SB7    0  IF UNSIGNED 
*                1  IF SIGNED (TRAILING OVERPUNCH)
*                2  IF SIGNED (TRAILING SEPERATE CHARACTER) 
*                3  IF SIGNED (LEADING OVERPUNCH) 
*                4  IF SIGNED (LEADING SEPERATE CHARACTER)
* 
*                RETURNS: 
*         B7 = 0 IF TRUE
*         B7 = 1 IF FALSE 
* 
 C.NUMR   OBJ    I=(B4,B5,B6,B7),O=B7,S=(X0,X6,X7,A0,A1,A2,A4,A6,A7,B2) 
          SPACE  3
* 
**        C.NUMRA - IF NUMERIC FOR USE WITH A-OPTION
* 
*                CALLING SEQ: 
*         SB4    BYTE OFFSET OF FIELD 
*         SB5    FWA FIELD
*         SB6    CHAR LENGTH OF FIELD 
*         SB7    0  IF UNSIGNED 
*                1  IF SIGNED (TRAILING OVERPUNCH)
*                2  IF SIGNED (TRAILING SEPERATE CHARACTER) 
*                3  IF SIGNED (LEADING OVERPUNCH) 
*                4  IF SIGNED (LEADING SEPERATE CHARACTER)
* 
*                RETURNS: 
*         B7 = 0 IF TRUE
*         B7 = 1 IF FALSE 
* 
 C.NUMRA  OBJ    I=(B4,B5,B6,B7),O=B7,S=(X0,X6,X7,A0,A1,A2,A4,A6,A7,B2) 
          SPACE  3
* 
**        C.N12RN -  NUMERIC DISPLAY TYPE 1 TO REGISTER NUMERIC 
* 
*         NUMERIC DISPLAY TYPE 1 IS-
*                SOURCE IS UNSIGNED, AND
*                10 OR LESS SOURCE DIGITS ARE PICKED UP, AND
*                NO SCALING 
* 
*         INPUT 
*                B3 = SOURCE ADDRESS
*                X2 = SOURCE BCP   (0 @ X2 < 2'18)
*                B4 = SOURCE LENGTH   (1 @ B4 @ 10) 
*                X3 = 10H0000000000 
* 
*         OUTPUT
*                X1 = SOURCE VALUE, RIGHT-JUSTIFIED, DISPLAY ZERO-FILLED
  
 C.N12RN  OBJ    I=(B3,X2,B4,X3),O=(X1),S=(X4,X5,X6,X7,A3,A4,A5,A6,A7,B2
,,B7) 
          SPACE  3
* 
**        C.N22RN -  NUMERIC DISPLAY TYPE 2 TO REGISTER NUMERIC 
* 
*         NUMERIC DISPLAY TYPE 2 IS-
*                SOURCE HAS TRAILING OVERPUNCH SIGN, AND
*                10 OR LESS SOURCE DIGITS ARE PICKED UP, AND
*                NO SCALING 
* 
*         INPUT 
*                B3 = SOURCE ADDRESS
*                X2 = SOURCE BCP   (0 @ X2 < 2'18)
*                B4 = SOURCE LENGTH   (1 @ B4 @ 10) 
*                X3 = 10H0000000000 
* 
*         OUTPUT
*                X1 = SOURCE VALUE, RIGHT-JUSTIFIED, DISPLAY ZERO-FILLED
  
 C.N22RN  OBJ    I=(B3,X2,B4,X3),O=(X1),S=(X4,X5,X6,X7,A1,A3,A4,A5,A6,A7
,,B2,B7)
* 
**        C.OPXX - OPEN FILE (XX IS FILE ORG) 
* 
*                CALLING SEQ: 
*         SA0    FIT ADDRESS
*         SB3    REWIND OPTION
*         SB5    PROCESSING DIRECTION 
*         SB6    RETURN 
*         EQ     C.OPEXX
* 
*                RETURNS
*         NOTHING 
* 
*         CALLS FOR EVERY FO MUST STAY IN ORDER 
*                EVEN IF SOME ARE NOT USED
* 
 C.OPAK   OBJ    I=(A0,B3,B5),SQ=Y,BREG=6 
 C.OPDA   OBJ    I=(A0,B3,B5),SQ=Y,BREG=6 
 C.OPIS   OBJ    I=(A0,B3,B5),SQ=Y,BREG=6 
 C.OPRL   OBJ    I=(A0,B3,B5),SQ=Y,BREG=6 
 C.OPSQ   OBJ    I=(A0,B3,B5),SQ=Y,BREG=6 
 C.OPWA   OBJ    I=(A0,B3,B5),SQ=Y,BREG=6 
*      SPECIAL FOR DA OPEN OUTPUT ONLY
 C.OPNDA  OBJ    I=(A0,B3,X1,B5),SQ=Y,BREG=6
* 
**        C.PERF - PROCESS STACK OF ACTIVE PERFORMS.
* 
*                CALLING SEQ: 
*         SB3    END-ADR
*         SB4    RETURN-ADR IF TO ENTER STACK ENTRY 
*                ZERO IF TO POP STACK ENTRY 
*         RJ     C.PERF 
* 
*                RETURNS: 
*         NOTHING 
* 
 C.PERF   OBJ    I=(B3,B4),S=B1,SQ=Y
          SPACE  3
* 
**        C.PERFS - SEGMENTED PERFORM 
* 
*         SEE C.PERF
* 
 C.PERFS  OBJ    I=(B3,B4)
          SPACE  3
* 
**        C.RDNXX - READ NEXT FROM FILE (XX IS THE FILE ORG)
* 
*                CALLING SEQ: 
*         SA0    FIT ADDRESS
*         MX4    1 IF AT END GIVEN, 0 IF NOT
*         SB6    RETURN 
*         EQ     C.RDNXX
* 
*                RETURNS: 
*         NOTHING 
* 
*         CALLS FOR EVERY FO MUST STAY IN ORDER 
* 
 C.RDNAK  OBJ    I=(A0,X4),O=(B3,X3),SQ=Y,BREG=6
 C.RDNDA  OBJ    I=(A0,X4),O=(B3,X3),SQ=Y,BREG=6
 C.RDNIS  OBJ    I=(A0,X4),O=(B3,X3),SQ=Y,BREG=6
 C.RDNRL  OBJ    I=(A0,X4),O=(B3,X1),SQ=Y,BREG=6
 C.RDNSQ  OBJ    I=(A0,X4),O=(B3,X3),SQ=Y,BREG=6
 C.RDNWA  OBJ    I=(A0,X4),O=(B3,X1),SQ=Y,BREG=6
          SPACE  3
* 
**        C.RDRXX - READ RANDOM FROM FILE (XX IS THE FILE ORG)
* 
*                CALLING SEQ: 
*         SA0    FIT ADDRESS
*         MX4    1 IF INVALID KEY GIVEN, 0 IF NOT 
*         SB6    RETURN 
*         EQ     C.RDRXX
* 
*                RETURNS: 
*         NOTHING 
* 
*         CALLS FOR EVERY FO MUST STAY IN ORDER 
* 
 C.RDRAK  OBJ    I=(A0,X4,X1),O=(B3,X3),SQ=Y,BREG=6 
 C.RDRDA  OBJ    I=(A0,X4,X1),O=(B3,X3),SQ=Y,BREG=6 
 C.RDRIS  OBJ    I=(A0,X4,X1),O=(B3,X3),SQ=Y,BREG=6 
 C.RDRRL  OBJ    I=(A0,X4,X1),O=(B3,X3),SQ=Y,BREG=6 
 C.RDRSQ  OBJ    I=(A0,X4,X1),O=(B3,X3),SQ=Y,BREG=6 
 C.RDRWA  OBJ    I=(A0,X4,X1),O=(B3,X1),SQ=Y,BREG=6 
          SPACE  3
* 
**        C.RDSXX - READ START (WITH KEY) FROM FILE 
* 
*                CALLING SEQUENCE 
*         SA0    FIT ADDRESS
*         SX2    KEY ORDINAL
*         MX4    1 IF INVALID KEY GIVEN, 0 IF NOT 
*         SB6    RETURN 
*         EQ     C.RDSXX
* 
*                RETURNS
*         NOTHING 
* 
*         CALLS FOR EVERY FO MUST STAY IN ORDER 
* 
 C.RDSAK  OBJ    I=(A0,X4,B3),O=(B3,X3),SQ=Y,BREG=6 
 C.RDSDA  OBJ    I=(A0,X4,B3),O=(B3,X3),SQ=Y,BREG=6 
 C.RDSIS  OBJ    I=(A0,X4,B3),O=(B3,X3),SQ=Y,BREG=6 
          SPACE  3
* 
**        C.RERCT - ADDS TO RERUN COUNT 
* 
*         INPUT IS FIT IN A0
*         NO OUTPUTS
* 
 C.RERCT  OBJ    I=A0,SQ=Y
          SPACE  3
* 
**        C.RERUN - TAKE A RERUN DUMP 
* 
*         INPUTS - NONE 
* 
*         OUTPUTS - NONE
* 
 C.RERUN  OBJ 
          SPACE  3
* 
**        C.RLSE - -RELEASE- A RECORD TO -SORT- 
* 
*         INPUT 
*                A0=SORT FILE (SD) FIT ADDRESS
*                X3=RECORD LENGTH (IN CHARACTERS) 
*                RJ  C.RLSE 
* 
*         OUTPUT - NOTHING
* 
 C.RLSE   OBJ    I=(A0,X3),SQ=Y 
          SPACE  3
* 
**        C.REWXX - REWRITE REC ON FILE (XX IS THE FILE ORG)
* 
*                CALLING SEQ: 
*         SA0    FIT ADDRESS
*         SA1    KEY IF RL - MX1 0 OTHERWISE
 CDCS     IFNE   OP.DCS,OP.NO 
*         SX7    RECORD ORDINAL (CDCS I/O)
 CDCS     ENDIF 
*         SX3    RECORD LENGTH
*         MX4    1 IF INVALID KEY GIVEN, 0 IF NOT 
*         SB6    RETURN 
*         EQ     C.REWXX
* 
*                RETURNS: 
*         NOTHING 
* 
*         CALLS FOR EVERY FO MUST STAY IN ORDER 
* 
 CDCS     IFNE   OP.DCS,OP.NO 
 C.REWAK  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.REWDA  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.REWIS  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.REWRL  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.REWSQ  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 CDCS     ELSE
 C.REWAK  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.REWDA  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.REWIS  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.REWRL  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.REWSQ  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 CDCS     ENDIF 
          SPACE  3
* 
**        C.RN1ND -  1-REGISTER NUMERIC TO SUBSCRIPTED NUMERIC DISPLAY
* 
*         INPUT 
*                X0   DESCRIPTOR   (SEE OBJECT ROUTINE) 
*                X2   SOURCE DIGITS   (RIGHT-JUST., DISPLAY ZERO-FILLED)
*                X3   CHARACTER OFFSET FROM DESTINATION ADDRESS 
*                       (0 @ X3 < 2'18) 
*                B3   DESTINATION ADDRESS 
*                B7   RETURN ADDRESS
* 
*         OUTPUT
*                (STORES VALUE INTO SPECIFIED ITEM) 
* 
 C.RN1ND  OBJ    I=(X0,X2,X3,B3),SQ=Y,BREG=7
          SPACE  3
* 
**        C.RN2ND -  2-REGISTER NUMERIC TO SUBSCRIPTED NUMERIC DISPLAY
* 
*         INPUT 
*                X0   DESCRIPTOR   (SEE OBJECT ROUTINE) 
*                X1   MOST SIGNIFICANT DIGITS OF SOURCE 
*                       (RIGHT-JUSTIFIED, DISPLAY ZERO-FILLED)
*                X2   LEAST SIGNIFICANT 10 DIGITS OF SOURCE 
*                X3   CHARACTER OFFSET FROM DESTINATION ADDRESS 
*                       (0 @ X3 < 2'18) 
*                B3   DESTINATION ADDRESS 
*                B7   RETURN ADDRESS
* 
*         OUTPUT
*                (STORES VALUE INTO SPECIFIED ITEM) 
* 
 C.RN2ND  OBJ    I=(X0,X1,X2,X3,B3),SQ=Y,BREG=7 
 C.RN2RN  OBJ    I=(X1,X2,B6,B7),O=(X4,X5),S=(B2,B3,X7,A0,A1,A2,A6,A7)
          SPACE  3
* 
**        C.RTOD - REAL ** DOUBLE 
* 
*         INPUT 
*                X1   BASE
*                X3   EXPONENT (UPPER HALF) 
*                X4   EXPONENT (LOWER HALF) 
* 
*         OUTPUT
*                X5   RESULT (UPPER HALF) 
*                X0   RESULT (LOWER HALF) 
*                B3   ERROR FLAG
* 
 C.RTOD   OBJ    I=(X1,X3,X4),O=(X5,X0,B3)
          SPACE  3
* 
**        C.RTOI - REAL ** INTEGER
* 
*         INPUT 
*                X1   BASE
*                X3   EXPONENT
* 
*         OUTPUT
*                X5   RESULT
*                B3   ERROR FLAG
* 
 C.RTOI   OBJ    I=(X1,X3),O=(X5,B3)
          SPACE  3
* 
**        C.RTOR - REAL ** REAL 
* 
*         INPUT 
*                X1   BASE
*                X3   EXPONENT
* 
*         OUTPUT
*                X5   RESULT
*                B3   ERROR FLAG
* 
 C.RTOR   OBJ    I=(X1,X3),O=(X5,B3)
          SPACE  3
* 
**        C.RTRN - -RETURN- A RECORD FROM -SORT- OR -MERGE- 
* 
*         INPUT 
*                A0=SORT/MERGE FILE (SD) FIT ADDRESS
*                RJ  C.RTRN 
* 
*         OUTPUT
*                B3 = 0 IF NORMAL RETURN
*                   " 0 IF AT END RETURN
*                X3 = RECORD LENGTH 
* 
 C.RTRN   OBJ    I=(A0),O=(B3,X3),SQ=Y
          SPACE  3
* 
**        C.R1S02 -  COMP-1 TO 2 DIGIT SIGNED NUMERIC DISPLAY 
* 
*         INPUT 
*                X1  SIGNED COMP-1 VALUE
*                      0 @ ABSOLUTE VALUE OF X1 < 10'2
* 
*         OUTPUT
*                X2  10 DIGIT NUMERIC DISPLAY VALUE 
*                      (NINES COMPLEMENT IF NEGATIVE.)
*                      (MOST SIGNIFICANT 8 DIGITS ARE ZERO OR NINE.)
 C.R1S02  OBJ    I=(X1),O=(X1),S=(X4,X5,X6,X7,A1,A2,A3,A4,A5,A6,A7,B1,B2
,,B3,B4,B5,B6,B7),SQ=N
          SPACE  3
* 
**        C.R1S06 -  COMP-1 TO 6 DIGIT SIGNED NUMERIC DISPLAY 
* 
*         INPUT 
*                X1  SIGNED COMP-1 VALUE
*                      0 @ ABSOLUTE VALUE OF X1 < 10'6
* 
*         OUTPUT
*                X1  10 DIGIT NUMERIC DISPLAY VALUE 
*                      (NINES COMPLEMENT IF NEGATIVE.)
*                      (MOST SIGNIFICANT 4 DIGITS ARE ZERO OR NINE.)
 C.R1S06  OBJ    I=(X1),O=(X1),S=(X4,X5,X6,X7,A0,A1,A3,A4,A5,A6,A7,B1,B2
,,B3,B4,B5,B7),SQ=N 
          SPACE  3
* 
**        C.R1S09 -  COMP-1 TO 9 DIGIT SIGNED NUMERIC DISPLAY 
* 
*         INPUT 
*                X1 = SIGNED COMP-1 VALUE 
*                      0 @ ABSOLUTE VALUE OF X1 < 10'9
* 
*         OUTPUT
*                X1  10 DIGIT NUMERIC DISPLAY VALUE 
*                      (NINES COMPLEMENT IF NEGATIVE.)
*                      (MOST SIGNIFICANT DIGIT IS ZERO OR NINE.)
 C.R1S09  OBJ    I=(X1),O=(X1),S=(X4,X5,X6,X7,A0,A3,A4,A5,A6,A7,B1,B2,B3
,,B4,B5,B6),SQ=N
          SPACE  3
* 
**        C.R1S10 -  COMP-1 TO 10 DIGIT SIGNED NUMERIC DISPLAY
* 
*         INPUT 
*                X1  SIGNED COMP-1 VALUE
*                      0 @ ABSOLUTE VALUE OF X1 < 10'10 
* 
*         OUTPUT
*                X1 = 0000000000 IF POSITIVE VALUE
*                     9999999999 IF NEGATIVE VALUE
*                X2 = 10 DIGIT NUMERIC DISPLAY VALUE
*                       (NINES COMPLEMENT IF NEGATIVE)
 C.R1S10  OBJ    I=(X1),O=(X1,X2),S=(X4,X5,X6,X7,A0,A3,A4,A5,A6,A7,B1,B2
,,B3,B4,B5,B6),SQ=N 
,,B4,B5,B6),SQ=N
          SPACE  3
* 
**        C.R1S14 -  COMP-1 TO 14 DIGIT SIGNED NUMERIC DISPLAY
* 
*         INPUT 
*                X1  SIGNED COMP-1 VALUE
*                      0 @ ABSOLUTE VALUE OF X1 < 10'14 
* 
*         OUTPUT
*                X1  MOST SIGNIFICANT 4 DIGITS RIGHT JUSTIFIED
*                      (NINES COMPLEMENT IF NEGATIVE.)
*                      (LEFT 6 CHARACTERS ARE ZERO OR NINE.)
*                X2  LEAST SIGNIFICANT 10 DIGITS. 
*                      (NINES COMPLEMENT FI NEGATIVE.)
 C.R1S14  OBJ    I=(X1),O=(X1,X2),S=(X5,X6,X7,A0,A1,A2,A4,A5,A6,A7,B1,B2
,,B3,B4,B5),SQ=N
          SPACE  3
* 
**        C.R1U02 -  COMP-1 TO 2 DIGIT UNSIGNED NUMERIC DISPLAY 
* 
*         INPUT 
*                X1  POSITIVE COMP-1 VALUE,  0 @ X1 @ 99
* 
*         OUTPUT
*                X1  10 DIGIT NUMERIC DISPLAY ITEM
*                      (MOST SIGNIFICANT 8 DIGITS WILL BE ZERO.)
 C.R1U02  OBJ    I=(X1),O=(X1),S=(X3,X4,X5,X6,X7,A0,A1,A2,A3,A4,A5,A6,A7
,,B1,B2,B3,B4,B5,B6,B7),SQ=N
          SPACE  3
* 
**        C.R1U06 -  COMP-1 TO 3-6 DIGIT UNSIGNED NUMERIC DISPLAY 
* 
*         INPUT 
*                X1  POSITIVE COMP-1 VALUE,  0 @ X1 @ 999999
* 
*         OUTPUT
*                X1  10 DIGIT NUMERIC DISPLAY ITEM
*                      (MOST SIGNIFICANT 4 DIGITS WILL BE ZERO.)
 C.R1U06  OBJ    I=(X1),O=(X1),S=(X4,X5,X6,X7,A0,A1,A3,A4,A5,A6,A7,B1,B2
,,B3,B4,B5,B6),SQ=N 
          SPACE  3
* 
**        C.R4S18 -  D. P. COMP-1 TO 18 DIGIT SIGNED NUMERIC DISPLAY
* 
*         INPUT 
*                X1  MOST SIGNIFICANT (14) DIGITS,
*                      NORMALIZED 
*                X2  LEAST SIGNIFICANT (4) DIGITS 
*                      EXPONENT OF X2 IS EXACTLY 48 LESS THAN 
*                      THE EXPONENT OF S1.
*                B3  SCALING FACTOR;  INPUT IS MULTIPLIED BY 10'B3. 
* 
*         OUTPUT
*                X1  MOST SIGNIFICANT 8 DIGITS
*                      (NINES COMPLEMENT IF NEGATIVE) 
*                      (LEFT TWO DIGITS ARE ZERO OR NINE) 
*                X2  LEAST SIGNIFICANT 10 DIGITS
*                      (NINES COMPLEMENT IF NEGATIVE) 
 C.R4S18  OBJ    I=(X1,X2,B3),O=(X1,X2),S=(X7,A0,A4,A6,A7,B1,B2,B4,B5,B6
,),SQ=N 
          SPACE  3
* 
**        C.R1U10 -  SIGNED COMP-1 TO 10-DIGIT UNSIGNED NUMERIC DISPLAY 
* 
*         INPUT 
*                X1 = SIGNED COMP-1 VALUE 
* 
*         OUTPUT
*                X1 = 10-DIGIT UNSIGNED NUMERIC DISPLAY 
 C.R1U10  OBJ    I=(X1),O=(X1),S=(X3,X4,X5,X6,X7,A0,A3,A4,A5,A6,A7,B1,B2
,,B3,B4,B5,B6),SQ=N 
          SPACE  3
* 
**        C.R22XF -  COMP-2 TO EXTERNAL FLOAT FORMAT
* 
*         INPUT 
*                X1  REGISTER COMP-2 VALUE
*                B3  SCALING FACTOR 
*                      (I.E. TRUE VALUE OF SOURCE IS X1 * 10'(-B3)) 
*                B4  BCP OF DESTINATION FIELD 
*                B5  FWA OF DESTINATION FIELD 
* 
*         OUTPUT
*                (NO REGISTER OUTPUT) 
 C.R22XF  OBJ    I=(X1,B3,B4,B5),SQ=Y 
          SPACE  3
* 
**        C.SETCS - SET COLLATING SEQUENCE
* 
*                CALLS IN TURN C.CVCS TO CONVERT 7 WORD WEIGHT TABLES 
*                TO 64 WORD WEIGHT TABLES (NON-CMU).
* 
*         CALLING SEQUENCE: 
* 
*         SB5    1           SET-SORT 
*                2           SET-MERGE
*                3           SET-SORT-MERGE 
*                4           SET-PROGRAM
*                5           SET-CODE-SET (NOT IMPLEMENTED) 
*         SB6    SEQUENCE TYPE (SEE -DNATVALS- COMMON DECK FOR
*                            CORRECT NUMBERS 1-8) 
*         SB7    ADDR OF USER SPECIFIED SEQ IF B6=1 
*         RJ     C.SETCS
* 
*                RETURNS: 
*         NOTHING 
* 
 C.SETCS  OBJ    I=(B5,B6,B7),SQ=Y,S=(B1,A0)
          SPACE  3
* 
**        C.SETDC - SET DECLARATIVE POINTER VECTOR ADDRESS
* 
*         INPUT  X1 = ADDRESS OF POINTER VECTOR 
* 
*         OUTPUT - NOTHING
* 
 C.SETDC  OBJ    I=X1,SQ=N,S=(X2,X3,X4,A0,A2,A3,A4,B1,B2,B3,B4,B5,B6) 
          SPACE  3
* 
**        C.SETSW - SET SWITCH ON/OFF 
* 
*                CALLING SEQUENCE 
*         SB3    SWITCH NBR 
*         SB4    1 IF ON, 0 IF OFF
*         RJ     =XC.SETSW
* 
 C.SETSW  OBJ    I=(B3,B4),S=(A2,A3,A4,A5,A7,B1,B5,B6,B7,X0,X3,X4,X5,X7)
,,SQ=N
          SPACE  3
* 
*         C.SORTI - INITIALIZE AND PERFORM SORT (VIA SORT/MERGE 5)
* 
*         INPUT 
*                A0=SORT FILE (SD) FIT ADDRESS
*                X0=ADDRESS OF KEY AND FILE INFO
*                X1=0 IF NO -COLLATING SEQUENCE- OPTION 
*                  =BITS 29-0 - COLLATING SEQUENCE NUMBER, AND
*                   BITS 59-30 - ADDRESS OF COLLATING SEQUENCE, IF
*                                USER-DEFINED 
*                X2=SORT RECORD LENGTH INCLUDING ALL KEYS 
*                B3=0 IF -USING-
*                  =1 IF -INPUT PROCEDURE-
*                X3=ADDRESS OF -USING- AREA OR -INPUT PROCEDURE- AREA 
*                   (NOTE OBJECT ROUTINE) 
*                B4=0 IF -GIVING- 
*                  =1 IF -OUTPUT PROCEDURE- 
*                X4=ADDRESS OF -GIVING- AREA OR -OUTPUT PROCEDURE- AREA 
*                   (NOTE OBJECT ROUTINE) 
*                X5=SMCON7 (ENTRY IN SORT/MERGE)
*                B7=RETURN ADDRESS
*                RJ  =XC.SORTI
* 
*         OUTPUT - NOTHING
* 
 C.SORTI  OBJ    I=(A0,X0,X1,X2,B3,X3,B4,X4,X5,B7),SQ=Y 
          SPACE  3
* 
  
**        C.STOPR - PROCESS STOP RUN STATEMENTS 
* 
*         INPUT:  
*                NONE 
* 
*         OUTPUT
*                NONE 
* 
 C.STOPR  OBJ 
  
* 
*         C.STRIN - STRING
* 
*         INPUT 
*                B3 = RESULT ADDRESS
*                B4 = RESULT BCP (+ SUBSC CHAR OFFSET IF SUBSCRIPTED) 
*                B5 = PARAMETER LIST ADDRESS
*                B6 = LAST PARAMETER ADDRESS
*                X1 = POINTER VALUE IN BINARY 
*                X3 = RESULTLENGTH
* 
*         PARAMETER LIST
* 
*         VFD    6/TYPE,18/LENGTH,18/ADDR,18/BCP
*           REPEATED FOR EACH DELIMITER AND SOURCE OPERAND
* 
*      TYPE HAS THE FOLLOWING VALUES -
*      NOTE THAT IDENTIFIER DELIMITERS HAVE TYPES OF 40B AND ABOVE, 
*      OTHER OPERANDS ARE 37B AND BELOW, SO OBJECT ROUTINES CAN USE 
*      PL AND NG INSTRUCTIONS TO CHECK FOR DELIMITERS TO SEARCH FOR.
*         00B = ALPHANUMERIC OPERAND
*         20B = SIZE DELIMITER
*         60B = IDENTIFIER DELIMITER (ALSO INSPECT BEFORE DELIMITER)
* 
*         OUTPUT
*                B7 = OVERFLOW FLAG 
*                X1 = POINTER VALUE IN BINARY 
* 
 C.STRIN  OBJ    I=(B3,B4,B5,B6,X1,X3),O=(B7,X1)
          SPACE  3
* 
**        C.STAXX - START AT REC ON FILE (XX IS THE FILE ORG) 
* 
*                CALLING SEQ: 
*         SA0    FIT ADDRESS
*         SA1    KEY IF RELATIVE, MX1 0 OTHERWISE 
*         SX3    KEY LENGTH 
*         SB3    KEY NUMBER 
*         SB4    RELATION 
*         MX4    1 IF INVALID KEY GIVEN, 0 IF NOT 
 CDCS     IFNE   OP.DCS,OP.NO 
*         SX7    KEY ORDINAL (CDCS I/O) 
 CDCS     ENDIF 
*         SB6    RETURN 
*         EQ     C.STAXX
* 
*                RETURNS: 
*         NOTHING 
* 
*         CALLS FOR EVERY FO MUST STAY IN ORDER 
* 
 CDCS     IFNE   OP.DCS,OP.NO 
 C.STAAK  OBJ    I=(A0,X4,X1,X3,B4,B3,X7),O=B3,SQ=Y,BREG=6
 C.STADA  OBJ    I=(A0,X4,X1,X3,B4,B3,X7),O=B3,SQ=Y,BREG=6
 C.STAIS  OBJ    I=(A0,X4,X1,X3,B4,B3,X7),O=B3,SQ=Y,BREG=6
 C.STARL  OBJ    I=(A0,X4,X1,X3,B4,B3,X7),O=B3,SQ=Y,BREG=6
 CDCS     ELSE
 C.STAAK  OBJ    I=(A0,X4,X1,X3,B4,B3),O=B3,SQ=Y,BREG=6 
 C.STADA  OBJ    I=(A0,X4,X1,X3,B4,B3),O=B3,SQ=Y,BREG=6 
 C.STAIS  OBJ    I=(A0,X4,X1,X3,B4,B3),O=B3,SQ=Y,BREG=6 
 C.STARL  OBJ    I=(A0,X4,X1,X3,B4,B3),O=B3,SQ=Y,BREG=6 
 CDCS     ENDIF 
          SPACE  4
* 
**        C.STPTR - STOP PARAGRAPH TRACE
* 
*         NO INPUTS - NO OUTPUTS
* 
*         CLOBBERS ALL REGISTERS
* 
 C.STPTR  OBJ 
          SPACE  3
* 
**        C.S08R1 -  1-8 DIGIT SIGNED NUMERIC DISPLAY TO COMP-1 
* 
*         INPUT 
*                X0 NEGATIVE MASK   (CREATED WITH MX0 N, N\12)
*                      INDICATES WHICH DIGITS TO CONVERT
*                X1  1-8 DIGIT SIGNED NUMERIC DISPLAY INPUT 
* 
*         OUTPUT
*                X1  SIGNED COMP-1 VALUE
* 
 C.S08R1  OBJ    I=(X0,X1),O=X1,S=(X6,X7,A0,A1,A4,A5,A6,A7,B1,B2,B3,B4,B
,5,B6,B7) 
          SPACE  3
* 
**        C.S09R1 -  9 DIGIT SIGNED NUMERIC DISPLAY TO COMP-1 
* 
*         INPUT 
*                X1  9 DIGIT SIGNED NUMERIC DISPLAY 
* 
*         OUTPUT
*                X1  SIGNED COMP-U VALUE
* 
 C.S09R1  OBJ    I=X1,O=X1,S=(X6,X7,A0,A1,A5,A6,A7,B1,B2,B3,B4,B5)
          SPACE  3
* 
**        C.S14R1 -  10-14 DIGIT SIGNED NUMERIC DISPLAY TO COMP-1 
* 
*         INPUT 
*                X0  NEGATIVE MASK   (CREATED WITH MX0 N, N\36) 
*                      INDICATES WHICH MOST SIG. DIGITS TO BE CONVERTED 
*                X1  MOST SIGNIFICANT 0-4 DIGITS
* 
*         OUTPUT
*                X1  SIGNED COMP-1 VALUE
* 
*         RJ     C.S14R1
 C.S14R1  OBJ    I=(X0,X1,X2),O=(X1),S=(X5,X6,X7,A0,A1,A3,A4,A5,A6,A7,B1
,,B2,B3,B4,B5)
          SPACE  3
* 
**        C.S18R4 -  15-18 DIGIT SIGNED NUMERIC DISPLAY TO COMP-1 
* 
*         INPUT 
*                X0  NEGATIVE MASK   (CREATED WITH MX0 N, N\12) 
*                      INDICATES WHICH DIGITS OF X1 TO BE CONVERTED 
*                X1 = MOST SIGNIFICANT 5-8 DIGITS,
*                      NINES COMPLEMENT IF NEGATIVE 
*                X2 = LEAST SIGNIFICANT 10 DIGITS,
*                      NINES COMPLEMENT IF NEGATIVE.
*                B5 = SCALING FACTOR: 
*                       RESULT WILL BE MULTIPLIED BY 10'(-B5) 
* 
*         OUTPUT
*                X1 = MOST SIGNIFICANT COMP-2 RESULT
*                      X1 IS NORMALIZED.
*                X2 = LEAST SIGNIFICANT COMP-2 RESULT 
*                      THE EXPONENT OF X2 IS EXACTLY 48 LESS THAN 
*                      THE EXPONENT OF X1.
 C.S18R4  OBJ    I=(X0,X1,X2,B5),O=(X1,X2),S=(X6,X7,A0,A1,A2,A5,A6,A7,B1
,,B2,B3),SQ=N 
          SPACE  4
* 
**        C.TRACE - PARAGRAPH TRACE 
* 
*         NO INPUTS - NO OUTPUTS
* 
*         CLOBBERS ALL REGISTERS
* 
 C.TRACE  OBJ 
          SPACE  3
* 
*         C.UNSTF - FAST UNSTRING 
* 
*         USED WHEN ALL DELIMITERS SIZE ONE AND NO DELIMITER-IN OR
*         COUNT-IN SPECIFIED AND NO NUMERIC OPERAND 
* 
*         INPUT-OUTPUT SAME AS C.UNSTR
* 
 C.UNSTF  OBJ    I=(B3,B4,B5,B6,X1,X2,X3),O=B7
          SPACE  4
* 
*         C.UNSTS - UNSTRING
* 
*         INPUT 
*                B3 = SOURCE ADDRESS
*                B4 = SOURCE BCP (+ SUBSC CHAR OFFSET IF SUBSCRIPTED) 
*                B5 = PARAMETER LIST ADDRESS
*                B6 = LAST PARAMETER ADDRESS
*                X1 = POINTER VALUE IN BINARY 
*                X2 = TALLYING VALUE IN BINARY
*                X3 = SOURCE LENGTH 
* 
*         VFD    6/TYPE,18/LENGTH,18/ADDR,18/BCP
*           REPEATED FOR EACH DELIMITER, DELIMITER IN, COUNT IN, AND
*           RESULT OPERAND
* 
*      THE PARAMETERS ARE GENERATED IN THE FOLLOWING ORDER
*       [ POINTER                    ] * IF POINTER 
*       [ TALLYING                   ] * IF TALLYING
*       [ FIRST DELIMITER            ] * IF DELIMITED BY
*       [ SECOND DELIMITER           ]
*         . . . 
*         FIRST RESULT
*       [ FIRST DELIMITER IN         ] * IF DELIMITER IN
*       [ FIRST COUNT IN             ] * IF COUNT IN
*         SECOND RESULT 
*       [ SECOND DELIMITER IN        ] * IF DELIMITER IN
*       [ SECOND COUNT IN            ] * IF COUNT IN
*         . . . 
* 
*         TYPE HAS THE FOLLOWING VALUES - 
*      NOTE THAT IDENTIFIER DELIMITERS HAVE TYPES OF 40B AND ABOVE, 
*      OTHER OPERANDS ARE 37B AND BELOW, SO OBJECT ROUTINES CAN USE 
*      PL AND NG INSTRUCTIONS TO CHECK FOR DELIMITERS TO SEARCH FOR.
*         00B = ALPHANUMERIC OPERAND
*         01B = JUSTIFIED RIGHT ALPHANUMERIC OPERAND
*         02B = SIGNED LEFT CHARACTER DISPLAY NUMBERIC OPERAND
*         03B = SIGNED LEFT OVERPUNCHED DISPLAY NUMERIC OPERAND 
*         04B = SIGNED RIGHT CHARACTER DISPLAY NUMERIC OPERAND
*         05B = SIGNED RIGHT OVERPUNCHED DISPLAY NUMERIC OPERAND
*         06B = UNSIGNED DISPLAY NUMERIC OPERAND
*         07B = BINARY NUMERIC OPERAND
*         10B = DELIMITER IN IDENTIFIER 
*         11B = JUSTIFIED RIGHT DELIMITER IN IDENTIFIER 
*         12B = SIGNED LEFT CHARACTER DISPLAY NUMBERIC COUNT IN IDENT 
*         13B = SIGNED LEFT OVERPUNCHED DISPLAY NUMERIC COUNT IN IDENT
*         14B = SIGNED RIGHT CHARACTER DISPLAY NUMERIC COUNT IN IDENT 
*         15B = SIGNED RIGHT OVERPUNCHED DISPLAY NUMERIC COUNT IN ID
*         16B = UNSIGNED DISPLAY NUMERIC COUNT IN IDENTIFIER
*         17B = BINARY NUMERIC COUNT IN IDENTIFIER
*         30B = POINTER PARAMETER (FIRST UNSTRING PARAMETER, IF PRESENT)
*         31B = TALLYING PARAMETER (FOLLOWS POINTER PARAM, IF PRESENT)
*         60B = IDENTIFIER DELIMITER (ALSO INSPECT BEFORE DELIMITER)
*         61B = ALL IDENTIFIER DELIMITER
* 
*         OUTPUT
*                B7 = OVERFLOW FLAG 
* 
 C.UNSTS  OBJ    I=(B3,B4,B5,B6,X1,X2,X3),O=B7
          SPACE  3
* 
**        C.U08R1 -  1-8 DIGIT UNSIGNED NUMERIC DISPLAY TO COMP-1 
* 
*         INPUT 
*                X0  NEGATIVE MASK   (CREATED WITH MX0 N, N\12) 
*                      INDICATES WHICH DIGITS TO CONVERT
*                X1  1-8 DIGIT UNSIGNED NUMERIC DISPLAY INPUT 
* 
*         OUTPUT
*                X1  POSITIVE COMP-1 RESULT 
* 
 C.U08R1  OBJ    I=(X0,X1),O=X1,S=(X4,X5,X6,X7,A0,A1,A4,A5,A6,A7,B1,B2,B
,3,B4,B5,B6)
          SPACE  3
* 
**        C.U09R1 -  9 DIGIT UNSIGNED NUMERIC DISPLAY TO COMP-1 
* 
*         INPUT 
*                X1  9 DIGIT UNSIGNED NUMERIC DISPLAY VALUE 
* 
*         OUTPUT
*                X1  POSITIVE COMP-1 VALUE
* 
 C.U09R1  OBJ    I=X1,O=X1,S=(X5,X6,X7,A0,A1,A5,A6,A7,B1,B2,B3,B4,B5) 
          SPACE  3
* 
**        C.U10R1 -  10 DIGIT UNSIGNED NUMERIC DISPLAY TO COMP-1
* 
*         INPUT 
*         X1 = 10 DIGIT UNSIGNED NUMERIC DISPLAY VALUE
* 
*         OUTPUT
*                X1  POSITIVE COMP-1 VALUE
* 
 C.U10R1  OBJ    I=(X1),O=(X1),S=(X4,X5,X6,X7,A0,A1,A3,A4,A5,A6,A7,B1,B2
,,B3,B4,B5,B6),SQ=N 
          SPACE  3
* 
**        C.U14R1 -  11-14 DIGIT UNSIGNED NUMERIC DISPLAY TO COMP-1 
* 
*         INPUT 
*                X0  NEGATIVE MASK   (CREATED WITH MX0 N, N\36) 
*                      INDICATES WHICH MOST SIG. DIGITS TO BE CONVERTED 
*                X1  MOST SIGNIFICANT 1-4 DIGITS
*                X2  LEAST SIGNIFICANT 10 DIGITS
* 
*         OUTPUT
*                X1  POSITIVE COMP-1 VALUE
* 
*         RJ     C.U14R1
  
 C.U14R1  OBJ    I=(X0,X1,X2),O=(X1),S=(X5,X6,X7,A0,A1,A3,A4,A5,A6,A7,B1
,,B2,B3,B4,B5,B6) 
          SPACE  3
* 
**        C.WAA - WRITE AFTER ADVANCING 
* 
*                CALLING SEQ: 
* 
*         SA0    FIT ADDR 
 CDCS     IFNE   OP.DCS,OP.NO 
*         SX7    RECORD ORDINAL (CDCS I/O)
 CDCS     ENDIF 
*         SX3    RECORD LENGTH
*         SX1    COUNT OR MNEMONIC
*         SB3    1 IF MNEMONIC, 0 IF INTEGER
*         SB6    RETURN 
*         EQ     C.WAA
* 
*         RETURNS NOTHING 
* 
 CDCS     IFNE   OP.DCS,OP.NO 
 C.WAA    OBJ    I=(A0,B3,X1,X3,X7),SQ=Y,BREG=6 
 CDCS     ELSE   1
 C.WAA    OBJ    I=(A0,B3,X1,X3),SQ=Y,BREG=6
          SPACE  3
* 
**        C.WBA - WRITE BEFORE ADVANCING
* 
*                CALLING SEQ: 
* 
*         SAME AS C.WAA EXCEPT CALL IS TO C.WBA 
* 
 CDCS     IFNE   OP.DCS,OP.NO 
 C.WBA    OBJ    I=(A0,B3,X1,X3,X7),SQ=Y,BREG=6 
 CDCS     ELSE   1
 C.WBA    OBJ    I=(A0,B3,X1,X3),SQ=Y,BREG=6
          SPACE  3
* 
**        C.WRIXX - WRITE REC ON FILE (XX IS THE FILE ORG)
* 
*                CALLING SEQ: 
*         SA0    FIT ADDRESS
 CDCS     IFNE   OP.DCS,OP.NO 
*         SX7    RECORD ORDINAL (CDCSI/O) 
 CDCS     ENDIF 
*         SX3    RECORD LENGTH
*         MX4    1 IF INVALID KEY GIVEN, 0 IF NOT 
*         SB6    RETURN 
*         EQ     C.WRIXX
* 
*                RETURNS: 
*         NOTHING 
* 
*         CALLS FOR EVERY FO MUST STAY IN ORDER 
* 
 CDCS     IFNE   OP.DCS,OP.NO 
 C.WRIAK  OBJ    I=(A0,X3,X4,X7),O=B3,SQ=Y,BREG=6 
 C.WRIDA  OBJ    I=(A0,X3,X4,X7),O=B3,SQ=Y,BREG=6 
 C.WRIIS  OBJ    I=(A0,X3,X4,X7),O=B3,SQ=Y,BREG=6 
 C.WRIRL  OBJ    I=(A0,X3,X4,X7),O=(B3,X1),SQ=Y,BREG=6
 C.WRISQ  OBJ    I=(A0,X3,X4,X7),O=B3,SQ=Y,BREG=6 
 C.WRIWA  OBJ    I=(A0,X3,X4,X7),O=(B3,X1),SQ=Y,BREG=6
 CDCS     ELSE
 C.WRIAK  OBJ    I=(A0,X3,X4),O=B3,SQ=Y,BREG=6
 C.WRIDA  OBJ    I=(A0,X3,X4),O=B3,SQ=Y,BREG=6
 C.WRIIS  OBJ    I=(A0,X3,X4),O=B3,SQ=Y,BREG=6
 C.WRIRL  OBJ    I=(A0,X3,X4),O=(B3,X1),SQ=Y,BREG=6 
 C.WRISQ  OBJ    I=(A0,X3,X4),O=B3,SQ=Y,BREG=6
 C.WRIWA  OBJ    I=(A0,X3,X4),O=(B3,X1),SQ=Y,BREG=6 
 CDCS     ENDIF 
          SPACE  3
* 
**        C.WRRXX - WRITE RANDOM ONTO FILE
* 
*                CALLING SEQUENCE 
*         SA0    FIT ADDRESS
*         SA1    KEY IF RL - MX1 0 OTHERWISE
 CDCS     IFNE   OP.DCS,OP.NO 
*         SX7    RECORD ORDINAL (CDCS I/O)
 CDCS     ENDIF 
*         SX3    RECORD LENGTH
*         MX4    1 IF INVALID KEY GIVEN, 0 IF NOT 
  
*         SB6    RETURN 
*         EQ     =XC.WRRXX
* 
 CDCS     IFNE   OP.DCS,OP.NO 
 C.WRRAK  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.WRRDA  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.WRRIS  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.WRRRL  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.WRRSQ  OBJ    I=(A0,X4,X1,X3,X7),O=B3,SQ=Y,BREG=6
 C.WRRWA  OBJ    I=(A0,X4,X1,X3,X7),O=(B3,X1),SQ=Y,BREG=6 
 CDCS     ELSE
 C.WRRAK  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.WRRDA  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.WRRIS  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.WRRRL  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.WRRSQ  OBJ    I=(A0,X4,X1,X3),O=B3,SQ=Y,BREG=6 
 C.WRRWA  OBJ    I=(A0,X4,X1,X3),O=(B3,X1),SQ=Y,BREG=6
 CDCS     ENDIF 
* 
**        C.PURGE - MCS REQUEST FOR PURGE VERB
* 
*         INPUT 
*                A0  CD ADDRESS 
*                B4  MAXIMUM LENGTH OF CD 
* 
*         OUTPUT
*                NONE 
* 
*         DOES
*                SETS UP MCS REQUEST FOR PURGE
*                CALLS MCS
*                ERROR ANALYSIS BEFORE AND AFTER CALLING MCS
* 
*         USES
*                A  0 1 - - - - 6 7 
*                X  0 1 2 3 - - - - 
*                B  - 1 2 - 4 - - - 
 C.PURGE  OBJ    I=(A0,B4)
* 
**        C.MCS12 - MCS REQUEST FOR ACCEPT MESSAGE COUNT
*                 - MCS REQUEST FOR INITIAL INPUT 
* 
*         INPUT 
*                A0  CD ADDRESS 
*                X4  1 INITIAL
*                    2 ACCEPT MESSAGE COUNT 
* 
*         OUTPUT
*                NONE 
* 
*         DOES
*                SETS UP MCS REQUEST PARAMETER BLOCK FOR
*                ACCEPT MESSAGE COUNT OR INITIAL INPUT
*                CALLS MCS
*                CHECKS FOR ERROR CONDITIONS AFTER CALLING MCS
* 
*         USES
*                A  0 1 2 - - - 6 7 
*                X  - 1 2 - - - 6 7 
*                B  0 1 2 3 - - - - 
 C.MCS12  OBJ    I=(A0,X4)
* 
**        C.EDOUT - MCS REQUEST FOR ENABLE/DISABLE OUTPUT 
* 
*         INPUT 
*                A0  CD ADDRESS 
*                X4  0 DISABLE
*                    1 ENABLE 
*                B4  MAXIMUM CD LENGTH
*                X0 THE PASSWORD
*                B7  LENGTH PASSWORD
* 
*         OUTPUT
*                NONE 
* 
*         DOES
*                SETS UP MCS REQUEST PARAMETER BLOCK
*                CALLS MCS
*                ERROR ANALYSIS BEFORE AND AFTER CALLING MCS
* 
*         USES
*                A  0 1 - - - - 6 7 
*                X  0 1 2 - 4 - 6 7 
*                B  0 1 2 3 4 5 6 7 
 C.EDOUT  OBJ    I=(A0,X4,B4,X0,B7) 
* 
**        C.EDIN
* 
*         INPUT 
*                A0  CD ADDRESS 
*                X4  0 DISABLE
*                    1 ENABLE 
*                B3  1 TERMINAL SPECIFIED 
*                    0 TERMINAL NOT SPECIFIED 
*                X0 THE PASSWORD
*                B7  LENGTH PASSWORD
* 
*         OUTPUT
*                NONE 
* 
*         DOES
*                SETS UP MCS REQUEST PARAMETER BLOCK
*                CALLS MCS
*                ERROR ANALYSIS BEFORE AND AFTER CALLING MCS
* 
*         USES
*                A  0 1 2 - - - 6 7 
*                X  0 1 - - 4 - 6 7 
*                B  0 1 2 3 4 5 6 7 
 C.EDIN   OBJ    I=(A0,X4,B3,X0,B7) 
* 
**        C.RECVE - MCS REQUEST FOR RECEIVE VERB
* 
*         INPUT 
*                A0  FWA CD 
*                B3  0 NO NO DATA 
*                    1 NO DATA
*                B4  0 RECEIVE MESSAGE
*                    1 RECEIVE SEGMENT
*                B5  FWA INTO IDENTIFIER
*                B6  BCP INTO IDENTIFIER
*                B7  LENGTH INTO IDENTIFIER 
* 
*         OUTPUT
*                NONE 
* 
 C.RECVE  OBJ    I=(A0,B3,B4,B5,B6,B7),O=(B3) 
* 
**        C.SEND - MCS REQUEST FOR SEND VERB
* 
*         INPUT 
*                A0  FWA OF CD-NAME 
*                X0  33B WITH PHRASE NOT SPECIFIED
*                    34B WITH ESI 
*                    35B WITH EMI 
*                    36B WITH EGI 
*                    VALUE IN THE WITH IDENTIFIER 
*                X1  INTEGER VALUE IN ADVANCING PHRASE
*                    MNEMONIC CHARACTER IN ADVANCING PHRASE 
*                    34B IF PAGE WAS SPECIFIED
*                    0 IF ADVANCING WAS NOT SPECIFIED 
*                X4  0 IF ADVANCING WAS NOT SPECIFIED 
*                    2 ADVANCING BEFORE PAGE/MNEMONIC 
*                    3 ADVANCING AFTER PAGE/MNEMONIC
*                    6 ADVANCING BEFORE INTEGER/IDENTIFIER
*                    7 ADVANCING AFTER INTEGER/IDENTIFIER 
*                B4  MAXIMUM LENGTH OF CD IN CHARACTERS 
*                B5  0 NO FROM PHRASE 
*                    FWA OF FROM IDENTIFIER 
*                B6  0 NO FROM PHRASE 
*                    BCP OF FROM IDENTIFIER 
*                B7  0 NO FROM PHRASE 
*                    LENGTH OF FROM IDENTIFIER
* 
*         OUTPUT
*                NONE 
 C.SEND   OBJ    I=(A0,X0,X1,X4,B4,B5,B6,B7)
* 
**        C.SLODL - SINGLE REGISTER LEFT JUSTIFIED LOAD 
* 
*         INPUT 
*                X3 - OFFSET
*                B3 - FWA 
*                B4 - LENGTH
* 
*         OUTPUT
*                X1 - LOADED ITEM (BLANK FILLED)
* 
 C.SLODL  OBJ    I=(X3,B3,B4),O=X1,S=(A0,A4,A5,A6,A7,X0,X4,X5,X6,X7,B6,B
,7) 
* 
**        C.DLODL - DOUBLE REGISTER LEFT JUSTIFIED LOAD 
* 
*         INPUT 
*                X3 - OFFSET
*                B3 - FWA 
*                B4 - LENGTH
*         OUTPUT
*                X1 - FIRST WORD OF ITEM
*                X2 - SECOND WORD (BLANK FILLED)
* 
 C.DLODL  OBJ    I=(X3,B3,B4),O=(X1,X2),S=(A0,A5,A6,A7,X0,X6,X7,B6,B7)
* 
**        C.SSOTR - SUBSCRIPTED STORE SINGLE REGISTER 
* 
*                X1 - ITEM TO STORE, JUSTIFIED RIGHT
*                B3 - DESTINATION ADDRESS 
*                X3 - DESTINATION OFFSET
*                B4 - DESTINATION LENGTH, CHARACTERS
* 
 C.SSTOR  OBJ    I=(X1,B3,X3,B4),S=(X0,X2,X7,A0,A1,A2,A3,A7)
* 
**        C.DSTOR - SUBSCRIPTED STORE TWO REGISTERS 
* 
*                X1 - FIRST WORD TO STORE 
*                X2 - SECOND WORD TO STORE, JUSTIFIED RIGHT 
*                B3 - DESTINATION ADDRESS 
*                X3 - DESTINATION OFFSET
*                B4 - DESTINATION LENGTH, CHARATCERS
* 
 C.DSTOR  OBJ    I=(X1,X2,B3,X3,B4),S=(A0,A1,A2,A3,A7,X0,X7)
  
 C.CLOSF  OBJ 
  
**
*         STOP RUN FILE CLOSING ROUTINE 
* 
*         CALLING SEQUENCE -
* 
*         RJ     C.CLOSF
* 
*         DESTORYS ALL REGESTERS
* 
**
  
 C.STOPL  OBJ    I=(B3,B4)
  
**
*         STOP LITERAL PROCESSING 
*         CALLING SEQUENCE -
*         SB3    FWA OF LITERAL 
*         SB4    SIZE 
*         RJ     C.STOPL
* 
*         DESTROYS ALL REGISTERS
* 
**
* 
**        C.CMURF - CMU MOVE WITH REFERENCE MODIFICATION
* 
*         INPUT 
*                X1 - LENGTH SOURCE 
*                X2 - LENGTH DESTINATION
*                X0 - NON ZERO IF DESTINATION JUSTIFIED RIGHT 
*                X4 - OFFSET DESTINATION
*                X5 - OFFSET SOURCE 
*                X3 - CMU DESCRIPTOR
 C.CMURF  OBJ    I=(X0,X1,X2,X3,X4,X5)
* 
**        C.ECARF - MOVE ECS TO AN WITH REFERENCE MODIFICATION
**        C.ECERF - MOVE ECS TO ECS WITH REFERENCE MODIFICATION 
**        C.AECRF - MOVE AN TO ECS WITH REFERENCE MODIFICATION
* 
*         INPUT 
* 
*                B3 - FWA DESTINATION 
*                B4 - BCP DESTINATION 
*                B5 - FWA SOURCE
*                B6 - BCP SOURCE
*                X0 - NON ZERO IF DESTINATION JUSTIFIED RIGHT 
*                X1 - LENGTH SOURCE 
*                X2 - LENGTH DESTINATION
 C.ECARF  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
 C.ECERF  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
 C.AECRF  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
* 
**        C.MOVRF - MOVE WITH REFERENCE MODIFICATION
* 
*         INPUT 
*                B3 - FWA DESTINATION 
*                B4 - BCP DESTINATION 
*                B5 - FWA SOURCE
*                B6 - BCP SOURCE
*                X0 - NON ZERO IF DESTINATION JUSTIFIED RIGHT 
*                X1 - LENGTH SOURCE 
*                X2 - LENGTH DESTINATION
 C.MOVRF  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
* 
**        C.BITCM - BOOLEAN BIT COMPARE 
* 
*         INPUT 
*                X1 = BYTE OFFSET A 
*                X2 = BYTE OFFSET B 
*                B3 = ADDRESS A 
*                B4 = ADDRESS B 
*                B5 = BIT LENGTH A
*                B6 = BIT LENGTH B
*         OUTPUT
*                B3 = 0 IF EQUAL, " 0 IF UNEQUAL
 C.BITCM  OBJ    I=(X1,X2,B3,B4,B5,B6),O=B3 
* 
**        C.BTDCM - BOOLEAN BIT TO BOOLEAN DISPLAY COMPARE
* 
*         INPUT 
*                X1 = BYTE OFFSET A 
*                X2 = BYTE OFFSET B 
*                B3 = ADDRESS A 
*                B4 = ADDRESS B 
*                B5 = BYTE LENGTH A 
*                B6 = BIT LENGTH B
*         OUTPUT
*                B3 = 0 IF EQUAL, "0 IF UNEQUAL 
 C.BTDCM  OBJ    I=(X1,X2,B3,B4,B5,B6),O=B3 
* 
*         C.BLDCM - BOOLEAN DISPLAY COMPARE 
* 
*         INPUT 
*                X1 = BYTE OFFSET A 
*                X2 = BYTE OFFSET B 
*                B3 = ADDRESS A 
*                B4 = ADDRESS B 
*                B5 = BYTE LENGTH A 
*                B6 = BYTE LENGTH B 
*         OUTPUT
*                B3 = 0 IF EQUAL, "0 IF UNEQUAL 
 C.BLDCM  OBJ    I=(X1,X2,B3,B4,B5,B6),O=B3 
* 
**        C.BT2BT - MOVE BOOLEAN BIT TO BOOLEAN BIT 
* 
*         INPUT 
*                B3 = ADDRESS DESTINATION 
*                B4 = BYTE OFFSET DESTINATION 
*                B5 = ADDRESS SOURCE
*                B6 = BYTE OFFSET DESTINATION 
*                X0 = JUSTIFIED FLAG
*                X1 = BIT LENGTH SOURCE 
*                X2 = BIT LENGTH DESTINATION
 C.BT2BT  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
* 
*         C.BT2BD - MOVE BOOLEAN BIT TO BOOLEAN DISPLAY 
* 
*         INPUT 
*                B3 = ADDRESS DESTINATION 
*                B4 = BYTE OFFSET DESTINATION 
*                B5 = ADDRESS SOURCE
*                B6 = BYTE OFFSET SOURCE
*                X0 = JUSTIFIED FLAG
*                X1 = BIT LENGTH SOURCE 
*                X2 = BYTE LENGTH DESTINATION 
 C.BT2BD  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
* 
**        C.BD2BT - MOVE BOOLEAN DISPLAY TO BOOLEAN BIT 
* 
*         INPUT 
*                B3 = ADDRESS DESTINATION 
*                B4 = BYTE OFFSET DESTINATION 
*                B5 = ADDRESS SOURCE
*                B6 = BYTE OFFSET SOURCE
*                X0 = JUSTIFIED FLAG
*                X1 = BYTE LENGTH SOURCE
*                X2 = BIT LENGTH DESTINATION
 C.BD2BT  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
* 
**        C.BD2BD - MOVE BOOLEAN DISPLAY TO BOOLEAN DISPLAY 
* 
*         INPUT 
*                B3 = ADDRESS DESTINATION 
*                B4 = BYTE OFFSET DESTINATIOM 
*                B5 = ADDRESS SOURCE
*                B6 = BYTE OFFSET SOURCE
*                X0 = JUSTIFIED FLAG
*                X1 = BYTE LENGTH SOURCE
*                X2 = BYTE LENGTH DESTINATION 
 C.BD2BD  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
* 
**        C.BT2AN - MOVE BOOLEAN BIT TO ALPHANUMERIC
* 
*         INPUT 
*                B3 = ADDRESS DESTINATION 
*                B4 = BYTE OFFSET DESTINATION 
*                B5 = ADDRESS SOURCE
*                B6 = BYTE OFFSET SOURCE
*                X0 = JUSTIFIED FLAG
*                X1 = BYTE LENGTH SOURCE
*                X2 = BIT LENGTH DESTINATION
 C.BT2AN  OBJ    I=(B3,B4,B5,B6,X0,X1,X2) 
* 
**        C.BT2AE - MOVE BOOLEAN BIT TO ALPHANUMERIC EDITED 
*                B3 = ADDRESS SOURCE
*                B4 = BYTE OFFSET SOURCE
*                B5 = ADDRESS DESTINATION DESCRIPTOR
*                B7 = BIT LENGTH SOURCE 
 C.BT2AE  OBJ    I=(B3,B4,B5,B7)
* 
**        C.BOOL  - BOOLEAN OPERATIONS
* 
*         INPUT 
*                B4 = ADDRESS OF PARAMETER LIST 
*                         RESULT DESCRIPTOR 
*                         OPERAND ONE DESCRIPTOR
*                         (OPERAND TWO DESCRIPTOR)
*                     DESCRIPTOR FORMAT 
*                         6/TYPE,18/OFFSET,18/LENGTH,18/ADDRESS 
*                         TYPE = 0 BIT , = 1 DISPLAY
*                B3 = OPERATOR
*                     1 = AND,  2 = OR, 3 = EXOR, 4 = NOT 
 C.BOOL   OBJ    I=(B3,B4)
* 
**        C.ABTCM - ALL LITERAL TO BOOLEAN BIT COMPARE
* 
*         INPUT 
*                X1 = BYTE OFFSET LITERAL 
*                X2 = BYTE OFFSET ITEM
*                B3 = ADDRESS LITERAL 
*                B4 = ADDRESS ITEM
*                B5 = BYTE LENGTH LITERAL 
*                B6 = BIT LENGTH ITEM 
*         OUTPUT
*                B3 = 0 IF EQUAL, "0 IF UNEQUAL 
 C.ABTCM  OBJ    I=(X1,X2,B3,B4,B5,B6),O=B3 
* 
**        C.ALL2B - MOVE ALL LITERAL TO BOOLEAN BIT 
* 
*         INPUT 
*                B3 = ADDRESS DESTINATION 
*                B4 = BYTE OFFSET DESTINATION 
*                B5 = ADDRESS LITERAL 
*                B6 = BYTE OFFSET LITERAL 
*                X1 = BYTE LENGTH LITERAL 
*                X2 = BIT LENGTH ITEM 
 C.ALL2B  OBJ    I=(B3,B4,B5,B6,X1,X2)
* 
**        C.DELFL - DELETE FILE 
* 
*         INPUTS
*                A0 = FIT ADDRESS 
*                B6 = RETURN ADDRESS
C.DELFL   OBJ    I=A0,SQ=Y,BREG=6 
          SPACE  3
* 
**        C.DMRSR - CDCS START RELATION 
* 
*         SA0    RELATION ORDINAL 
*         MX1    0
*         SX3    KEY LENGTH 
*         SB3    KEY NUMBER 
*         SB4    RELATION 
*         MX4    1 IF NO INK KEY, 0 IF ONE
*         SX7    KEY ORD
*         SB6    RETURN 
*         EQ     C.DMRSR
  
 C.DMRSR  OBJ    I=(A0,X4,X1,X3,B4,B3,X7),O=B3,SQ=Y,BREG=6
**        C.MERGE - S/M VERS 4 MERGE INTERFACE - SEE C.MERGI
 C.MERGE  OBJ    I=(A0,X0,X1,B3,X3,B4,X4,X5,B7),SQ=Y
**        C.SORT - S/M VERS 4 SORT INTERFACE - SEE C.SORTI
 C.SORT   OBJ    I=(A0,X0,X1,X2,B3,X3,B4,X4,X5,B7),SQ=Y 
* 
**        C.AL2AE -  MOVE ALL LITERAL TO AN ALPHA EDITED FIELD
* 
*         INPUT 
*                X2  SOURCE SIGN TYPE,BCP, LENGTH 
*                B3  ADDRESS DESTINATION DESCRIPTOR 
*                B4  ADDRESS SOURCE 
*         OUTPUT
*                (NO REGISTER OUTPUT) 
 C.AL2AE  OBJ    I=(B4,B3,X2) 
          SPACE  3
* 
**        C.R4TRU - TRUNCATE R4 VALUE TO INTEGER
* 
*         INPUT 
*              DPCOMP2 REGISTER VALUE KNOWN AS *IN*:  
*                X1 = MOST  SIG. PART OF DPCOMP2 TO BE TRUNCATED
*                X2 = LEAST SIG. PART OF DPCOMP2 TO BE TRUNCATED
*         OUTPUT
*              DPCOMP2 REGISTER VALUE KNOWN AS *OUT*: 
*                X3 = MOST  SIG. PART OF TRUNCATED DPCOMP2
*                X4 = LEAST SIG. PART OF TRUNCATED DPCOMP2
 C.R4TRU  OBJ    I=(X1,X2),O=(X3,X4)
*      END OF OBJDEFS - DO *B THIS CARD FOR CHECKOUT - ASSEMBLE TABLES
*      AND CGENTXT
