*DECK C$ND2RN 
          IDENT  C$ND2RN
          TITLE  C.ND2RN -  SUBSCRIPTED NUMERIC TO REGISTER NUMERIC 
  
          MACHINE  ANY,I
          COMMENT  SUBSCRIPTED NUMERIC TO REGISTER NUMERIC
          B1=1
          SPACE  4
**        C.ND2RN -  SUBSCRIPTED NUMERIC TO REGISTER NUMERIC
* 
*         B3 = SOURCE ADDRESS 
* 
*         X0 = 42/ UNUSED (EXCEPT FOR NOTE BELOW) 
*              4/ SHIFT INDICATOR AFTER BOTH FIELDS ARE 
*                  ALIGNED ON LEAST SIGNFICANT DIGITS:  
*                            0000  (SEE NOTE BELOW) 
*                            0001  RESULT RIGHT-SHIFTED 7 DIGITS
*                            0010  RESULT RIGHT-SHIFTED 6 DIGITS
*                            ...
*                            0111  RESULT RIGHT-SHIFTED 1 DIGIT 
*                            1000  NO SHIFTING
*                            1001  RESULT PADDED WITH 1 ZERO ON RIGHT 
*                            1010  RESULT PADDED WITH 2 ZEROS ON RIGHT
*                            ...
*                            1111  RESULT PADDED WITH 7 ZEROS ON RIGHT
*              1/ =1 IFF DESTINATION IS SIGNED, 
*              5/ TRUNCATION INDICATOR
*                  EITHER ZERO (NO TRUNCATION)
*                  OR  20 - (DESTINATION LENGTH), 
*              1/ =1 IFF SOURCE HAS SEPARATE SIGN,
*              1/ =1 IFF SOURCE HAS LEADING SIGN, 
*              1/ =1 IFF SOURCE IS SIGNED,
*              5/ NUMERIC LENGTH OF SOURCE
* 
*         X1 = CHARACTER OFFSET FROM SOURCE ADDRESS 
*                (0 @ OFFSET < 2'18)
* 
*         NOTE-  THE SPECIFICATIONS OF COBOL REQUIRE THE CAPABILITY 
*         OF SHIFTING UP TO 17 DIGITS TO THE RIGHT OR LEFT. 
*         WITH REGISTER X0 BEING SET WITH A SINGLE *SET X-REGISTER* 
*         INSTRUCTION, ONLY 7 DIGITS MAY BE EASILY SPECIFIED. 
*         WHEN THE 4-BIT SHIFT INDICATOR = 0000 THE UPPER 42 BITS 
*         OF REGISTER X0 INDICATE THE SHIFT COUNT (THUS REQUIRING 
*         SEVERAL INSTRUCTIONS TO SET UP X0). 
*         THE UPPER 12 BITS OF X0 IS THE BIASED SHIFT INDICATOR,
*         SUITABLE FOR EXTRACTING WITH AN *UNPACK* INSTRUCTION: 
*                            -17   RESULT RIGHT-SHIFTED 17 DIGITS 
*                            ...
*                            -8    RESULT RIGHT-SHIFTED 8 DIGITS
*                            8     RESULT PADDED WITH 8 ZEROS ON RIGHT
*                            ...
*                            17    RESULT PADDED WITH 17 ZEROS ON RIGHT 
* 
*         RJ     C.ND2RN
* 
*         SETS X1 = (SIGNED) MOST SIGNIFICANT DIGITS OF RESULT. 
*         SETS X2 = (SIGNED) LEAST SIGNIFICANT DIGITS OF RESULT.
* 
*         USES-  X  0 1 2 3 4 - - - 
*                A  0 1 2 3 4 - - - 
*                B    * - 3 4 5 6 7    *B1=1
  
*CALL CCPARCM 
  
          ENTRY  C.ND2RN
 C.ND2RN  DATA   0
  
*      COMPUTE ADDRESS, ENDING CHARACTER POSITION, SOURCE LENGTH, SIGN
  
          SB7    B0          ASSUME POSITIVE SIGN 
          MX2    -5 
          BX2    -X2*X0      NUMERIC LENGTH OF SOURCE 
          SX4    X2-1        (NUMERIC LENGTH OF SOURCE) - 1 
          SX3    1S20/10+1
          IX1    X1+X4       CHARACTER OFFSET OF RIGHT-MOST DIGIT 
          IX3    X3*X1       (OFFSET/10) * 2'20 
          AX3    20          WORD OFFSET
          SB3    B3+X3       NEW ADDRESS
          IX2    X3+X3       WORD OFFSET * 2
          LX3    3           WORD OFFSET * 8
          IX3    X3+X2       WORD OFFSET * 10 
          IX3    X1-X3       CHARACTER OFFSET FROM NEW ADDRESS  (0 _ 9) 
          IX4    X4-X3       (LENGTH-1) - (OFFSET (= 0_9))
          SB6    X4-10
  
*      LOAD RIGHT-MOST WORD 
  
          SA2    B3 
  
*      COMPUTE SHIFT COUNT TO RIGHT-JUSTIFY WORD
  
          SB4    X3+B1       0_1, 1_2, ..., 9_10
          SA0    B4          SAVE CHARACTER COUNT FOR FINAL PADDING 
          SB5    B4+B4       2* 
          SB4    B5+B5       4* 
          SB4    B4+B5       6* 
  
*      IF SOURCE HAS SEPARATE SIGN,  GO PROCESS IT
  
          LX0    -8          BIT 59 = 1 IFF SOURCE HAS SEPARATE SIGN
          NG     X0,SEPSIGN  IF SOURCE HAS SEPARATE SIGN
          LX0    8           RESET X0 
 C.ND2RN1 BSS    0           (RETURN FROM SEPARATE SIGN PROCESSING) 
  
*         X0 = DESCRIPTOR 
*         X3 = ENDING CHARACTER OFFSET  (0 _ 9) 
*         B3 = ADDRESS OF LAST WORD 
*         B6 = (NUMERIC LENGTH OF SOURCE) - 1 - OFFSET - 10 
*         B7 = SIGN OF SOURCE (AS FAR AS KNOWN) 
  
*      RIGHT-JUSTIFY, BINARY ZERO-FILL SOURCE WORD
  
          SA4    =X_C.MASK+X3+1    (X3+1)77-S, (9-X3)00-S 
          LX2    X2,B4       RIGHT-JUSTIFY SOURCE 
          LX4    X4,B4       (60-B4)/0, (B4)/77...77B 
          BX2    X4*X2       STRIP GARBAGE FROM LEFT OF X2
  
*      IF TRAILING OVERPUNCH SIGN,  GO PROCESS IT 
  
          LX0    -7          BIT 59 = 0 IFF TRAILING SIGN 
          PL     X0,TRAIL 
          LX0    7
 C.ND2RN2 BSS    0           (RETURN FROM TRAILING SIGN PROCESSING) 
  
*      IF NO MORE SOURCE WORDS, SKIP
  
          SB5    -10
          LE     B6,B5,C.ND2RN3    IF ORIG. LENGTH \ CHARACTER POSITION 
  
*      LOAD NEXT WORD 
  
          SA1    A2-B1
  
*      MERGE FIRST AND SECOND TARGET WORDS
  
          LX1    X1,B4       RIGHT-JUSTIFY SOURCE WORD
          BX3    X4*X1       EXTRACT MORE SIGNIFICANT DIGITS
          BX1    -X4*X1      EXTRACT REST OF FIRST WORD 
          BX2    X1+X2       COMBINE FOR COMPLETE LEAST SIG. DIGITS 
          LX1    X3          PUT MOST SIGNIFICANT DIGITS IN X1
  
*         X0 = DESCRIPTOR 
*         X1 = PART OF MOST SIGNIFICANT DIGITS
*         A1 = ADDRESS OF LAST LOADED WORD
*         X2 = LEAST SIGNIFICANT DIGITS 
*         X4 = MASK TO SEPARATE SOURCE WORDS
*         B4 = SHIFT COUNT TO JUSTIFY SOURCE INTO TARGET
*         B6 = NUMBER OF SOURCE CHARACTERS NOT IN LAST WORD - 10
*         B7 = SIGN OF SOURCE   (AS MUCH AS IS KNOWN) 
  
*      IF NO MORE SOURCE WORDS, SKIP
  
          LE     B6,B0,C.ND2RN3 
  
*      LOAD AND INTEGRATE NEXT WORD 
  
          SA3    A1-B1
          LX3    X3,B4       RIGHT-JUSTIFY LAST WORD
          BX3    -X4*X3      EXTRACT LEFT PART OF ALIGNED SOURCE WORD 
          BX1    X3+X1       COMBINE TO GET MOST SIGNIFICANT DIGITS 
  
*      HANDLE LEADING OVERPUNCH SIGN
  
 C.ND2RN3 LX0    -7          BIT 59 = 1 IFF LEADING SIGN
          NG     X0,LEAD     IF LEADING SIGN, GO PROCESS
          LX0    7           RESET X0 
 C.ND2RN4 BSS    0           (RETURN FROM LEADING SIGN PROCESSING)
  
*      PAD ZEROS
  
          SB6    A0+B6
          SB6    -B6         (NUMBER OF ZEROS TO PAD) - 10
          GE     B6,B0,PADX2 IF PADDING INTO LEAST SIGNIFICANT DIGITS 
  
*      PAD ZEROS INTO WORD OF MOST SIGNIFICANT DIGITS 
  
          SA4    =X_C.MASK+B6+10  GET MASK FOR ZERO CHARACTERS
          SA3    =X_C.ZEROS  GET WORD OF DISPLAY ZEROS
          BX1    -X4*X1      RIGHT PART OF MOST SIGNIFICANT DIGITS
          BX3    X4*X3       LEFT PART = ZEROS
          IX1    X1+X3       COMPLETE MOST SIGNIFICANT DIGITS 
 DONEPAD  BSS    0           (RETURN FROM PADDING INTO X2)
  
*      PERFORM SHIFTING/PADDING ACCORDING TO SCALE INDICATOR
  
          LX0    -14
          MX3    -4 
          BX3    -X3*X0      SHIFT INDICATOR
          LX0    14 
          ZR     X3,PATHO    IF EXTENDED SHIFTING/PADDING 
          SB3    X3-10B      REMOVE BIAS
          NZ     B3,SCALE    IF SIMPLE SHIFTING/PADDING 
 C.ND2RN5 BSS    0           (RETURN FROM SHIFTING/PADDING) 
  
*      IF TRUNCATION IS NECESSARY,  GO DO IT
  
          LX0    -8          RIGHT-JUSTIFY TRUNCATION INDICATOR 
          MX3    -5 
          BX3    -X3*X0      EXTRACT TRUNCATION INDICATOR 
          LX0    8           RESET X0 
          NZ     X3,TRUNCAT  IF TRUNCATION,  GO DO IT 
 C.ND2RN6 BSS    0           (RETURN FROM TRUNCATION) 
  
*      IF DESTINATION IS SIGNED,  APPLY SIGN FROM SOURCE
  
          LX0    -14         BIT 59 = 1 IFF DESTINATION IS SIGNED 
          SX3    B7          777...776B IF -,  0 OR 1 IF +
          SA4    =XC.CCPAR
          LX4    59-#LBZ
          PL     X4,C.ND2RN7 NO LBZ OPTION
          SB7    -1R
          SB6    1R0&1R 
 1        DUP    10 
+         LX1    6
          MX4    -6 
          BX4    -X4*X1 
          SX4    X4+B7
+         NZ     X4,*+1 
          SX4    B6 
          BX1    X1-X4
 1        ENDD
 2        DUP    10 
+         LX2    6
          MX4    -6 
          BX4    -X4*X2 
          SX4    X4+B7
+         NZ     X4,*+1 
          SX4    B6 
          BX2    X2-X4
 2        ENDD
 C.ND2RN7 BSS    0
          PL     X0,C.ND2RN  UNSIGNED 
          PL     X3,C.ND2RN  POSITIVE SIGN
          SA4    =XC.ZEROS
          IX0    X1-X4
          NZ     X0,C.ND2RN8
          IX0    X2-X4
          ZR     X0,C.ND2RN  MINUS ZERO 
 C.ND2RN8 BX1    -X1         APPLY SIGN 
          BX2    -X2
          EQ     C.ND2RN     EXIT 
          TITLE  LEAD 
**        LEAD -  PROCESS LEADING OVERPUNCH SIGN
* 
*         X0 = DESCRIPTOR  (SHIFTED LEFT 53 BITS) 
*         X1 = MOST SIGNIFICANT DIGITS  (UNLESS SHORT SOURCE) 
*         X2 = LEAST SIGNIFICANT DIGITS 
*         B4 = LEFT-SHIFT COUNT TO RIGHT-JUSTIFY SOURCE WORD
*         B6 = INDICATOR FOR LENGTH OF SOURCE.
*         A0 =
* 
*         EQ     LOAD 
* 
*         RESETS X0.
*         SETS B7 = SIGN. 
*         RESUMES NORMAL PROCESSING AT C.ND2RN4.
  
  
 LEAD     BX4    X0 
          LX4    -1          BIT 59 = 1 IFF SEPARATE SIGN 
          LX0    7           RESET X0 
          NG     X4,C.ND2RN4 IF SOURCE HAS LEADING SEPARATE SIGN, RESUME
          SB7    A0+B6
          SB7    B1-B7       BCP+1
          SB7    B7+B7       2*(BCP+1)
          MX4    -6          77777777777777777700B
          SX3    B7+B7       4*(BCP+1)
          SB7    X3+B7       6*(BCP+1)
          SB5    60 
          GT     B7,B0,LEAD2 IF SIGN IN X2
  
*      SIGN IS IN X1
  
*         X1 = MOST SIGNIFICANT DIGITS
*         B5 = 60 
*         B7 = 6*(BCP+1) RELATIVE TO BEGINNING OF X2
*         X4 = 77777777777777777700B
  
 LEAD1    SB7    B7+B5       6*(BCP+1)+60 = SHIFT COUNT TO RIGHT JUSTIFY
*                            SIGNED DIGIT 
          LX1    X1,B7       BITS 5-0 = SIGNED DIGIT
          BX3    -X4*X1      EXTRACT SIGNED DIGIT 
          SA3    =X_C.STRP+X3  1/SIGN, 53/0, 6/(UNSIGNED DIGIT)&(SIGNED)
          SB7    B5-B7       LEFT-SHIFT COUNT TO RESET X1 
          SX4    X3          54/0, 6/(UNSIGNED DIGIT)&(SIGNED DIGIT)
          AX3    58          777...776B IF -,  1 IF + 
          BX1    X1-X4       CONVERT SIGNED DIGIT TO UNSIGNED 
          LX1    X1,B7       RESET X1 
          SB7    X3          SAVE SIGN
          EQ     C.ND2RN4    RESUME NORMAL PROCESSING 
  
  
*      SIGN IS IN X2
  
*         X2 = LEAST SIGNIFICANT DIGITS 
*         X4 = 77777777777777777700B
*         B5 = 60 
*         B7 = 6*(BCP+1) RELATIVE TO BEGINNING OF X2
  
 LEAD2    LX2    X2,B7       BITS 5-0 = SIGNED DIGIT
          BX3    -X4*X2      EXTRACT SIGNED DIGIT 
          SA3    =X_C.STRP+X3  1/SIGN, 53/0, 6/(UNSIGNED DIGIT)&(SIGNED)
          SB7    B5-B7       LEFT-SHIFT COUNT TO RESET X2 
          SX4    X3          54/0, 6/(UNSIGNED DIGIT)&(SIGNED DIGIT)
          AX3    58          777...776B IF -,   1 IF +
          BX2    X2-X4       CONVERT SIGNED DIGIT TO UNSIGNED 
          LX2    X2,B7       RESET X2 
          SB7    X3          SAVE SIGN
          EQ     C.ND2RN4    RESUME NORMAL PROCESSING 
          TITLE  PADX2
**        PADX2 -  PAD ZEROS INTO X2
* 
*         X0 = DESCRIPTOR 
*         X2 = LEAST SIGNIFICANT DIGITS 
*         B6 = NUMBER OF ZEROS TO PAD + 10
*         B7 = SIGN OF SOURCE 
  
  
 PADX2    SA4    =X_C.MASK+B6  GET MASK FOR ZERO CHARACTERS 
          SA1    =X_C.ZEROS  SET MOST SIGNIFICANT DIGITS = ZEROS
          BX2    -X4*X2      RIGHT PART OF LEAST SIGNIFICANT DIGITS 
          BX3    X4*X1       LEFT PART = ZEROS
          IX2    X2+X3       COMPLETE LEAST SIGNIFICANT DIGITS
          EQ     DONEPAD     RESUME NORMAL PROCESSING 
          TITLE  PATHO
**        PATHO -  PATHOLOGICAL SHIFTING/PADDING
* 
*         X0 = DESCRIPTOR 
*         X1 = MOST SIGNIFICANT DIGITS OF RESULT
*         X2 = LEAST SIGNIFICANT DIGITS OF RESULT 
*         B7 = SIGN OF SOURCE.
* 
*         EQ     PATHO
* 
*         SHIFTS/PADS X1 AND X2 ACCORDING TO CESCRIPTOR.
*         MAY CALL *SCALE* TO DO THE WORK  (IF SHORT CASE). 
*         RESUMES NORMAL PROCESSING AT C.ND2RN5.
  
  
 PATHO    UX3    B3,X0       EXTRACT EXTENDED SHIFT INDICATOR 
          NG     B3,PATHO2   IF SHIFTING RIGHT
          SB4    10 
          LT     B3,B4,SCALE IF SHIFTING WITHIN A SINGLE REGISTER 
          EQ     B3,B4,PATHO1  IF NOT REALLY SHIFTING 
          SB3    B3-B4
  
*      LEFT-SHIFT X2 BY B3 CHARACTERS INTO X1,
*      THEN SET X2 = ZEROS. 
  
          SA4    =X_C.MASK+B3 
          SB4    B3+B3       2* 
          BX1    -X4*X2      RIGHT PART OF X2 
          SA2    =X_C.ZEROS  10H0000000000
          SB5    B4+B4       4* 
          BX4    X4*X2       LEFT PART = ZEROS
          SB4    B5+B4       6* 
          IX1    X4+X1       COMBINE
          LX1    X1,B4       SHIFT
          EQ     C.ND2RN5    RESUME NORMAL PROCESSING 
  
  
*      LEFT-SHIFT EXACTLY 10 DIGITS 
  
 PATHO1   BX1    X2          SET MOST SIGNIFICANT DIGITS = LEAST SIG. 
          NO
          SA2    =X_C.ZEROS  SET LEAST SIGNIFICANT DIGITS = ZEROS 
          EQ     C.ND2RN5    RESUME NORMAL PROCESSING 
  
  
*      RIGHT-SHIFT
  
 PATHO2   SB4    -10
          GT     B3,B4,SCALE1      IF SHIFTING WITHIN SINGLE REGISTER 
          EQ     B3,B4,PATHO3      IF NOT REALLY SHIFTING 
  
*      RIGHT-SHIFT X1 INTO X2 ACCORDING TO B3,
*      THEN SET X1 = ZEROS. 
  
          SB3    B3+20       -17_3, -16_4, ..., -11_9 
          SB4    B3+B3       2* 
          SB5    B4+B4       4* 
          SB4    B5+B4       6* 
          LX2    X1,B4       SHIFT
          SA1    =X_C.ZEROS  SET MOST SIGNIFICANT DIGITS = ZEROS. 
          EQ     C.ND2RN5    RESUME NORMAL PROCESSING 
  
  
*      NOT REALLY RIGHT-SHIFTING
  
 PATHO3   BX2    X1          SET LEAST SIGNIFICANT DIGITS = MOST SIG. 
          NO
          SA1    =X_C.ZEROS  SET MOST SIGNIFICANT DIGITS = ZEROS
          EQ     C.ND2RN5    RESUME NORMAL PROCESSING 
          TITLE  SCALE
**        SCALE -  SCALE THE RESULT WITHIN A SINGLE REGISTER SHIFT
* 
*         X0 = DESCRIPTOR 
*         X1 = MOST SIGNIFICANT DIGITS OF RESULT
*         X2 = LEAST SIGNIFICANT DIGITS OF RESULT 
*         B3 = SCALE
*         B7 = SIGN OF SOURCE.
* 
*         EQ     SCALE
*      OR EQ     SCALE1      (FOR RIGHT-SHIFTING) 
* 
*         SCALE IS CALLED FROM NORMAL PROCESSING FOR
*           -7 @ B3 @ -1 OR 1 @ B3 @ 7. 
*         SCALE IS CALLED FROM PATHO FOR
*           -9 @ B3 @ -8, OR 8 @ B3 @ 9.
* 
*         SHIFTS/PADS X1 AND X2 ACCORDING TO B3.
*         RESUME NORMAL PROCESSING AT C.ND2RN5. 
  
  
 SCALE    NG     B3,SCALE1   IF SHIFTING RIGHT
          SA4    =X_C.MASK+B3 
          SB4    B3+B3       LEFT-SHIFT COUNT * 2 
          BX1    -X4*X1      RIGHT PART OF MOST SIGNIFICANT DIGITS
          SB5    B4+B4       LEFT-SHIFT COUNT * 4 
          BX3    X4*X2       LEFT PART OF LEAST SIGNIFICANT DIGITS
          SB4    B5+B4       LEFT-SHIFT COUNT * 6 
          BX1    X1+X3       NEW MOST SIG. DIGITS, UNSHIFTED
          SA3    =X_C.ZEROS  10H0000000000
          BX2    -X4*X2      RIGHT PART OF LEAST SIGNIFICANT DIGITS 
          LX1    X1,B4       NEW MOST SIGNFICANT DIGITS 
          BX3    X4*X3       LEFT PART OF LEAST SIG. DIGITS = ZEROS 
          IX2    X3+X2       NEW LEFT SIGNIFICANT DIGITS, UNSHIFTED 
          LX2    X2,B4       NEW LEAST SIGNIFICANT DIGITS 
          EQ     C.ND2RN5    RESUME NORMAL PROCESSING 
  
  
*      SHIFTING RIGHT 
  
 SCALE1   SB5    -B3         SET INDEX TO MASK TABLE
          SA4    =X_C.MASK+B5 
          SB3    B3+10       -9_1, -8_2, ..., -1_9
          SB4    B3+B3       RIGHT-SHIFT COUNT * 2
          SB5    B4+B4       RIGHT-SHIFT COUNT * 4
          SB4    B5+B4       RIGHT-SHIFT COUNT * 6
          LX1    X1,B4       SHIFT MOST SIGNIFICANT DIGITS
          LX2    X2,B4       SHIFT LEAST SIGNIFICANT DIGITS 
          BX2    -X4*X2      RIGHT PART OF LEAST SIGNIFICANT DIGITS 
          BX3    X4*X1       LEFT PART OF MOST SIGNIFICANT DIGITS 
          BX2    X2+X3       COMPLETE LEAST SIGNIFICANT DIGITS
          SA3    =X_C.ZEROS  10H0000000000
          BX1    -X4*X1      RIGHT PART OF MOST SIGNIFICANT DIGITS
          BX3    X4*X3       LEFT PART = ZEROS
          IX1    X1+X3       COMPLETE MOST SIGNIFICANT DIGITS 
          EQ     C.ND2RN5    RESUME NORMAL PROCESSING 
          TITLE  SEPSIGN
**        SEPSIGN -  PROCESS SEPARATE SIGN
* 
*         X0 = DESCRIPTOR  (SHIFTED LEFT 52 BITS) 
*         X2 = CONTENTS OF LAST SOURCE WORD 
*         X3 = ENDING CHARACTER OFFSET  (0_9) 
*         B3 = ADDRESS OF LAST SOURCE WORD
*         B4 = LEFT-SHIFT COUNT TO RIGHT-JUSTIFY SOURCE WORD
*         B6 = (NUMERIC LENGTH OF SOURCE) - 1 - OFFSET - 10 
*         A0 = (B4)/6 
* 
*         EQ     SEPSIGN
* 
*         SETS B7 = SIGN:  777776B IF -,  1 IF +
*         RESETS X0 TO ITS ORIGINAL POSITION. 
*         RESUMES NORMAL PROCESSING AT C.ND2RN1.
  
  
 SEPSIGN  LX4    X0,B1       BIT 59 = 1 IFF LEADING SIGN
          LX0    8           RESET X0 
          NG     X4,SEPSIGN2 IF SOURCE HAS LEADING SIGN 
          SB5    X3-9 
          ZR     B5,SEPSIGN1 IF SIGN IS IN FOLLOWING WORD 
          LX4    X2,B4       BITS 59-54 = SIGN CHARACTER
          LX4    4           BITS 59-58 = 10 IF -,  01 IF + 
          AX4    58          777...776B IF -,  1 IF + 
          SB7    X4          SAVE SIGN
          EQ     C.ND2RN1    RESUME NORMAL PROCESSING 
  
  
*      SOURCE IS IN FOLLOWING WORD
  
 SEPSIGN1 SA4    B3+B1       BITS 59-54 = SIGN CHARACTER
          LX4    4           BITS 59-58 = 10 IF -,  01 IF + 
          AX4    58          777...776B IF -,  1 IF + 
          SB7    X4          SAVE SIGN
          EQ     C.ND2RN1    RESUME NORMAL PROCESSING 
  
  
*      SOURCE HAS LEADING SEPARATE SIGN 
  
 SEPSIGN2 SA4    B3+0        ASSUME FIRST WORD = LAST WORD
          SB5    B6+10       -(BCP OF MOST SIG. DIGIT) IF CORRECT 
          LT     B5,B0,SEPSIGN3  IF CORRECT ASSUMPTION,  SKIP 
          SB5    B6          -(BCP OF MOST SIG. DIGIT) IF CORRECT 
          SA4    A4-B1       ASSUME LAST WORD = FIRST WORD - 1
          LT     B5,B0,SEPSIGN3  IF CORRECT ASSUMPTION,  SKIP 
          SB5    B6-10       -(BCP OF MOST SIG. DIGIT)
          SA4    A4-B1       FIRST WORD MUST BE LAST WORD - 2 
 SEPSIGN3 SB5    -B5
          SB7    B5+B5       2* 
          SB5    B7+B7       4* 
          SB7    B5+B7       6* 
          LX4    X4,B7       BITS 5-0 = SIGN CHARACTER
          LX4    4-6         BITS 59-58 = 10 IF -, 01 IF +
          AX4    58          777...776B IF -, 1 IF +
          SB7    X4          SAVE SIGN
          EQ     C.ND2RN1    RESUME NORMAL PROCESSING 
          TITLE  TRAIL
**        TRAIL -  PROCESS TRAILING OVERPUNCH SIGN
* 
*         X0 = DESCRIPTOR  (SHIFTED LEFT 53 BITS) 
*         X2 = RIGHT-JUSTIFIED, BINARY ZERO-FILLED SOURCE WORD
*         X7 = (NUMERIC LENGTH OF SOURCE - 1) - OFFSET
*         B4 = SHIFT COUNT TO RIGHT-JUSTIFY SOURCE WORD 
*         B7 = (SIGN OF SOURCE) 
* 
*         RESETS X0 TO ITS ORIGINAL POSITION. 
*         IF SOURCE IS UNSIGNED OR HAS SEPARATE SIGN, EXITS TO C.ND2RN2.
*         SETS B7 = 777...776B IF SOURCE IS NEGATIVE,  0 IF POSITIVE. 
*         CONVERTS SIGNED DIGIT TO UNSIGNED DIGIT.
*         EXITS TO C.ND2RN2.
  
  
 TRAIL    LX1    X0,B1       BIT 59 = 1 IFF SOURCE IS SIGNED
          LX0    7           RESET X0 
          PL     X1,C.ND2RN2 IF SOURCE IS UNSIGNED, EXIT TO C.ND2RN2
          LX1    -2          BIT 59 = 1 IFF SEPARATE SIGN 
          NG     X1,C.ND2RN2 IF TRAILING SEPARATE SIGN
          MX1    -6          77777777777777777700B
          BX1    -X1*X2      SIGNED DIGIT 
          SA1    =X_C.STRP+X1  1/SIGN, 53/0, 6/(SIGNED DIGIT)&(UNSIGNED)
          SX3    X1          (SIGNED DIGIT)&(UNSIGNED DIGIT)
          AX1    58          777...776B IF -,  0 IF + 
          BX2    X2-X3       STRIP SIGN 
          SB7    X1          SET SIGN 
          EQ     C.ND2RN2    EXIT TO C.ND2RN2 
          TITLE  TRUNCAT
**        TRUNCAT -  TRUNCATE DIGITS ON THE LEFT FROM FINAL RESULT
* 
*         X0 = DESCRIPTOR  (SHIFTED LEFT 52 BITS) 
*         X1 = MOST SIGNIFICANT 10 DIGITS  (UNSIGNED) 
*         X2 = LEAST SIGNIFICANT 10 DIGITS  (UNSIGNED)
*         X3 = TRUNCATION INDICATOR 
* 
*         CONVERTS LEADING (X3) DIGITS TO ZEROS.
  
  
 TRUNCAT  SB3    X3-10
          GE     B3,B0,TRUNCAT1  IF TRUNCATING LEAST SIG. DIGITS
          SA3    =X_C.MASK+X3 
          SA4    =X_C.ZEROS 
          BX4    X3*X4
          BX1    -X3*X1 
          IX1    X1+X4
          EQ     C.ND2RN6 
  
 TRUNCAT1 SA3    =X_C.MASK+B3 
          SA1    =X_C.ZEROS 
          BX2    -X3*X2 
          BX4    X3*X1
          BX2    X4+X2
          EQ     C.ND2RN6 
  
  
          END 
