*DECK S$GNRF
          IDENT S$GNRF
          TITLE  S$GNRF - GENERATE- REVERT FLOATING SIGN
          COMMENT  GENERATE- REVERT FLOATING SIGN 
*CALL LBLPTR
          SPACE  4
**        S$GNRF - GENERATE- REVERT FLOATING SIGN 
* 
*      CALLING SEQUENCE-
*         S$GNRF(OFFSET,LENGTH,ASC,KEYORSUM); 
* 
*     GIVEN-
*         OFFSET = NUMBER OF BIT STARTING THE KEY FIELD IN THE
*          EXTERNAL RECORD.  THE FIRST BIT IS NUMBER 0. 
*         LENGTH = NUMBER OF BITS IN THE KEY FIELD OF THE EXTERNAL
*          RECORD.
*         ASC = NON-ZERO IF KEY IS ASCENDING. 
*             = ZERO IF KEY IS DESCENDING.
*         KEYORSUM = 1 FOR SUM, 0 FOR KEY 
* 
*      DOES-
*         GENERATES CODE. 
*         S$LK IS INCREMENTED BY S$GNRST BY THE LENGTH
*             OF THIS INTERNAL FIELD
* 
*      GENERATED CODE DOES- 
*         FOR EACH GROUP OF TEN OR FEWER CHARACTERS TO BE FILLED
*         IN THE EXTERNAL RECORD -
*         1. ASKS S$GNRNX FOR THE APPROPRIATE NUMBER OF BITS
*         2. IF X4 = KEY
*            INVERTS (I.E. RESTORES) THE LEFTMOST BIT 
*         3. IF B4 = DESCENDING 
*            COMPLEMENTS THE BINARY NUMBER
          ENTRY  S$GNRF 
S$GNRF    SUBR
  
* GET PARAMETERS INTO PROPER REGISTERS
  
          SB1    1           B1 = CONSTANT 1
          SA2    X1          VALUE OF OFFSET
          SB2    X2          B2 = OFFSET
          SA2    A1+1        ADDRESS OF LENGTH
          SA2    X2          VALUE OF LENGTH
          SB3    X2          B3 = LENGTH
          SA2    A1+2        ADDRESS OF ASC 
          SA2    X2          VALUE OF ASC 
          SB4    X2          B4 = ASC 
          SA2    A1+3        ADDRESS OF KEYORSUM
          SA4    X2          X4 = VALUE OF KEYORSUM 
  
  
* SAVE ORIGINAL VALUES OF B2,B3,B4 AND X4 
  
          SX6    B2 
          SA6    SAVEB2 
          SX6    B3 
          SA6    SAVEB3 
          SX6    B4 
          SA6    SAVEB4 
          SX6    X4 
          SA6    SAVEX4 
  
* SET UP A WORD OF CHARACTER ZEROS FOR GENERATED CODE TO USE
* ALSO SET ASIDE A WORD TO HOLD RECORD DESCRIPTOR 
  
          NEWLBL NEXT 
          GEN    (EQ "NEXT")
         *USES   B6,B7,X0,AX1-3,AX6 
          NEWLBL ZEROS
          GENLBL ZEROS
          GENMAC (DATA 10H0000000000) 
          NEWLBL HOLDX6 
          GENLBL HOLDX6 
          GENMAC (DATA 0) 
          GENLBL NEXT 
  
* SET B4 = LENGTH OF A GROUP OF 10 OR FEWER DIGITS
  
GNRFTOP   SB4    60 
          IFTHEN B3<B4
            SB4  B3 
            ENDIF.
  
          SA4    SAVEX4      GET VALUE FOR KEYORSUM 
          IFTHEN X4"0        IF A SUM FIELD 
            SB7    B4        HOLD TEMPORARY B4 IN B7
            SB4    B3        RETAIN LARGE LENGTH IF NECESSARY 
            ENDIF.
  
* NOW FIGURE OUT HOW MANY BITS THAT IS INTERNALLY 
  
          SX1    B4 
          SX2    1S19/6+1              1/6 * 2'19 
          IX1    X1*X2                 N/6 * 2'19 
          AX1    19                    N/6
          SA1    S$TBL1+X1             NUMBER OF BITS FOR UNSIGNED FIELD
          SX1    X1+1        NUMBER OF BITS FOR SIGNED FIELD
          IFTHEN X4"0        IF A SUM FIELD 
            SB4    B7          UNDO SWITCH OF PREVIOUS LINES
            ENDIF.
  
* ASK S$GNRNX FOR THAT MANY BITS
* S$GNRNX DESTROYS B4, UNFORTUNATELY
  
          SX7    B4 
          SA7    SAVEB42     SAVE INTERMEDIATE B4 
  
  
          SB5    X1 
                             S$IRRL, S$LR,S$LK,S$ORSA 
          CALL   S$GNRNX               *X4 CONTAINS INTERNAL FIELD
         *USES   B4,B6,B7,X0,AX1-3,AX6
                             X5 = OFFSET WITHIN *X4 OF INTERNAL FIELD 
                             S$LK INCREMENTED BY B5 
  
* LEFT-JUSTIFY THE FIELD
  
          IFTHEN X5"0 
            GEN    (LX4 0),X5 
            ENDIF.
* INVERT (I.E. RESTORE) LEFTMOST BIT IF NECESSARY 
  
          SA1    SAVEX4      GET VALUE FOR KEYORSUM 
          IFTHEN X1=B0       IF THIS IS A KEY FIELD 
            GEN    (MX1 1)   ONE-BIT MASK 
            GEN    (BX4 X4-X1) INVERT SIGN BIT
            ENDIF.
  
* COMPLEMENT BINARY NUMBER IN *X4 IF NECESSARY
  
          SA1    SAVEB4      GET VALUE FOR ASC/DESC 
          IFTHEN X1=B0       IF DESCENDING
            GEN    (BX4 -X4) INVERT NUMBER
            ENDIF.
  
* BY NOW THE TRUE SIGN IS IN THE LEFTMOST BIT 
* PUT THIS SIGN INTO *X0
          GEN    (BX0 X4) 
          GEN    (AX0 60)              *PROPAGATE SIGN BIT
  
* SAVE RECORD DESCRIPTOR IF THIS IS THE FIRST GROUP 
* ALSO SET -FRONTPART- TO TRUE WITH FLAG IN *B5 
  
          SA1    SAVEB2      GET ORIGINAL OFFSET
          SB7    X1          B7 = ORIGINAL OFFSET 
          IFTHEN B7=B2
            GEN    (SA6 "HOLDX6") 
            GEN    (SB5 B1)  FRONTPART = TRUE 
            ENDIF.
  
* NOW CONVERT THE BINARY NUMBER TO ITS ABSOLUTE VALUE 
  
          NEWLBL NEXT 
          GEN    (PL,X4,"NEXT") 
          GEN    (BX4 -X4)
          GENLBL NEXT 
  
* SHIFT THE ENORMOUS NUMBER OVER TO PROPER POSITION 
*  ON THE RIGHT 
  
          SB6    60 
          IFTHEN B5<B6
            SB6    B6-B5      60 MINUS BIT LENGTH 
            GEN    (AX4 0),B6 
            ENDIF.
  
  
          SA1    SAVEX4 
          IFTHEN X1"0 
            SA1    SAVEB3 
            SB3    X1 
            SB7    60 
            IFTHEN B3>B7   IF SUM FIELD > 60 BITS 
              EQ     GNRF2   GO DO SPECIAL CODE 
              ENDIF.
            ENDIF.
  
  
* GET READY FOR CONVERSION
  
          SA1    SAVEB42     GET INTERMEDIATE B4 BACK 
          SB4    X1 
          GEN    (MX6 0)     CLEAR RESULT REGISTER - *X6
          GEN    (SX7 10)    INTEGER 10 
          GEN    (PX5 X7,B0)
          GEN    (NX5)       FLOATING POINT 10 (NORMALIZED) 
  
* EXTRACT THE LEAST SIGNIFICANT DIGITS ONE BY ONE 
  
GNRF1     GEN    (PX1 X4,B0)  PACK AND NORMALIZE *X4
          GEN    (NX1)             INTO *X1 
          GEN    (FX2 X1/X5)  F.P. - X1/10
          GEN    (UX2 X2,B7)
          GEN    (LX2 B7)     INTEGER - X1/10 
          GEN    (IX3 X2*X7)  INTEGER - X1/10*10
          GEN    (IX3 X4-X3)  LEAST SIGNIFICANT DIGIT 
          GEN    (BX6 X6+X3)  STUFF IT INTO *X6 
          GEN    (LX6 -6)     SHIFT AROUND FOR NEXT TIME
          SB4    B4-6         6 MORE BITS REVERTED
          GEN    (BX4 X2) 
          NZ     B4,GNRF1    LOOP IF MORE TO DO 
  
* WHEN WE GET HERE, THE NUMBER IS LYING IN *X6
* IN THE FOLLOWING FORMAT :-
*      01020304050607101112 
* SO NOW ADD 10 CHARACTER ZEROS TO IT 
  
          GEN    (SA1 "ZEROS")
          GEN    (IX6 X1+X6)
  
* HANDLE LEADING SPACES AND MINUS SIGN IF NECESSARY 
* WE KNOW IF IT IS NECESSARY BY CHECKING -FRONTPART-
* FLAG IN *B5  1=FRONTPART 0=BACKPART 
  
          NEWLBL NEXT 
          NEWLBL EASIEST
          GEN    (EQ B5,B0,"EASIEST")    FRONTPART = FALSE,SO SKIP
  
* IF WE GET HERE, WE ARE IN THE LEADING PART OF THE NUMBER
* (NO DIGITS FOUND YET). THERE ARE 2 POSSIBILITIES IN 
* THIS SITUATION :- 
*  1) WE GET A ZERO -- CONVERT IT TO A SPACE (33B -> 55B) 
*        UNLESS IT IS THE LAST CHARACTER IN THE GROUP AND 
*        THIS IS THE LAST/ONLY GROUP. IN THIS CASE, LEAVE IT AT 
*        33B AND CHECK FOR POSSIBLE MINUS SIGN NEEDED.
*  2) WE GET A DIGIT(NONZERO) -- SET FRONTPART TO FALSE 
*                             -- INSERT MINUS SIGN IF NECESSARY 
  
* SET *B6 TO NUMBER OF CHARACTERS IN THIS GROUP 
  
          SB7    60 
          IFTHEN B3<B7
            GEN    (SB6 0),B3 
          ELSE- 
            GEN    (SB6 60) 
            ENDIF.
  
* IS THIS THE LAST/ONLY GROUP? IF SO, SET LASTGROUP (*B7) TO
* TRUE, ELSE SET IT TO FALSE. 
  
          SB7    61 
          IFTHEN B3<B7
            GEN    (SB7 1)             *LASTGROUP = TRUE
          ELSE- 
            GEN    (SB7 B0)            *LASTGROUP = FALSE 
            ENDIF.
  
          GEN    (MX1 -6)              *X1 = ONE-BYTE MASK
          GEN    (MX7 0)               *CLEAR RESULT REGISTER 
  
          NEWLBL RFLOOP 
          NEWLBL LAST 
          NEWLBL EASY 
          NEWLBL MINUS
          NEWLBL MINUS2 
          NEWLBL MINUS3 
          NEWLBL SPACE
          NEWLBL SPACE2 
          NEWLBL VERYLAST 
          NEWLBL GETOUT 
  
          GENLBL RFLOOP 
          GEN    (MX3 0)               CLEAR TEMP REGISTER
          GEN    (LX6 6)               LEFT-JUST NEXT CHAR
          GEN    (LX7 6)               SHIFT RESULT REGISTER
          GEN    (BX3 -X1*X6)          ONE CHAR IN *X3
          GEN    (SB6 B6-6)            DECREMENT COUNTER
          GEN    (EQ B6,B0,"LAST")     LAST CHAR IN GROUP 
          GEN    (EQ B5,B0,"EASY")     NO LONGER FRONTPART
          GEN    (SB3 X3)              B3 = X3 (ONE CHAR) 
          GEN    (SB4 33B)             B4 = CHAR ZERO 
          GEN    (EQ B3,B4,"SPACE")    LEADING ZERO -> SPACE
  
* IF WE GET HERE, WE HAVE FOUND THE FIRST DIGIT OF THE
* ENTIRE STRING -- SO WE SET FRONTPART TO FALSE 
  
          GEN    (SB5 B0)              FRONTPART = FALSE
          GEN    (BX7 X7+X3)           STUFF IN NEW DIGIT 
  
* TEST IF NECESSARY TO INSERT MINUS SIGN
  
          GEN    (NG X0,"MINUS")       LOOKS LIKE WE HAVE TO
          GEN    (EQ "RFLOOP")         GO DO ANOTHER
  
          GENLBL MINUS
          GEN    (LX7 -6)              BACK UP ONE CHAR 
          GEN    (BX7 X7*X1)           ERASE THAT CHAR
          GEN    (SX4 46B)             MINUS SIGN 
          GEN    (BX7 X7+X4)           STUFF IN MINUS SIGN
          GEN    (LX7 6)               GO BACK TO PLACE BEFORE
          GEN    (EQ "RFLOOP")         GO DO ANOTHER
  
* HANDLE SPECIAL CASES
  
          GENLBL EASY 
          GEN    (BX7 X7+X3)
          GEN    (EQ "RFLOOP")
  
          GENLBL SPACE
          GEN    (SX3 55B)
          GEN    (BX7 X7+X3)
          GEN    (EQ "RFLOOP")
  
* LAST CHARACTER IN THIS GROUP, BUT POSSIBLY STILL FRONTPART
  
          GENLBL LAST 
          GEN    (EQ B5,B0,"GETOUT")      NO LONGER IN FRONTPART
          GEN    (EQ B7,B1,"VERYLAST")        OH BOY
  
* THIS IS NOT THE LAST/ONLY GROUP - CHECK FOR MINUS SIGN IN 
* THIS GROUP WITH DIGITS COMING IN NEXT GROUP 
  
          GEN    (SB3 X3)              *B3 = *X3
          GEN    (SB4 33B)             *B4 = CHARACTER ZERO 
          GEN    (EQ B3,B4,"MINUS2")
* THIS CODE HAS NOTHING TO DO WITH LONG SUM FIELDS BUT SIMPLY 
* FIXES A BUG IN STANDARD S$GNRF
  
          NEWLBL NEXT2
          GEN    (PL X0,"NEXT2")
  
* WE NEED TO INSERT A MINUS SIGN IN FRONT OF THIS LAST DIGIT
  
          GEN    (LX7 -6) 
          GEN    (BX7 X7*X1)
          GEN    (SX4 46B)
          GEN    (BX7 X7+X4)
          GEN    (LX7 6)
          GENLBL NEXT2
          GEN    (EQ "GETOUT")
  
          GENLBL MINUS2 
          GEN    (PL X0,"GETOUT") 
  
* WELL, THIS IS IT - A MINUS SIGN HERE AND DIGITS COMING
  
          GEN    (SX3 46B)             PUT MINUS SIGN IN *X3
          GEN    (BX7 X7+X3)
          GEN    (SB5 B0)              FRONTPART = FALSE
          GEN    (EQ "NEXT")
  
* WE GET HERE IF LAST CHARACTER IN GROUP IS NOT A SPECIAL 
* CASE (I.E. MINUS SIGN WITH NO DIGITS) 
  
          GENLBL GETOUT 
          GEN    (EQ B3,B4,"SPACE2")   IF CHAR IS ZERO
  
* LAST CHAR IN GROUP IS NONZERO -- STORE IT AND SET 
* FRONTPART TO FALSE
  
          GEN    (BX7 X7+X3)
          GEN    (SB5 B0)              FRONTPART = FALSE
          GEN    (EQ "NEXT")
  
          GENLBL SPACE2 
          GEN    (SX3 55B)             *X3 = SPACE
          GEN    (BX7 X7+X3)
          GEN    (EQ "NEXT")
  
          GENLBL VERYLAST 
  
* WE ARE AT THE LAST CHARACTER IN THE WHOLE STRING AND *STILL*
* IN FRONTPART. IN THIS CASE, THE DIGIT WILL SIMPLY BE PUT
* INTO *X7 AS IS AND WE CHECK FOR MINUS (-9,-0,ETC.)
  
          GEN    (BX7 X7+X3)
          GEN    (NG X0,"MINUS3") 
          GEN    (EQ "NEXT")
  
          GENLBL MINUS3 
          GEN    (LX7 -6)              BACK UP ONE CHAR 
          GEN    (BX7 X7*X1)           ERASE THAT CHAR
          GEN    (SX4 46B)             *X4 = MINUS SIGN 
          GEN    (BX7 X7+X4)           STUFF IN MINUS SIGN
          GEN    (LX7 6)               GO BACK TO PLACE BEFORE
          GEN    (EQ "NEXT")
  
  
          GENLBL NEXT 
  
* AT THIS POINT, THE STRING IN *X7 IS RIGHT-JUSTIFIED 
* SO NOW WE LEFT-JUSTIFY IT IF NECESSARY
  
          SB7    60 
          IFTHEN B3<B7
            SB7    B7-B3
            GEN    (LX7 0),B7 
            ENDIF.
          NEWLBL NEXT 
          GEN    (EQ "NEXT")
  
  
  
          GENLBL EASIEST
  
          GEN    (BX7 X6) 
  
  
* ALL CONVERTED NOW, SO STORE IT IN EXTERNAL RECORD 
  
          GENLBL NEXT 
  
  
          SX5    0           OFFSET IN *X7 IS ALWAYS ZERO 
          SB5    60 
          IFTHEN B3<B5
            SB5    B3        IF LENGTH < 60 
            ENDIF.
                             B2 HAS OFFSET IN EXTERNAL RECORD 
  
          CALL   S$GNRST
  
* DECREMENT THE TOTAL LENGTH OF THE FIELD BY THIS GROUP,
* INCREMENT THE OFFSET, AND LOOP IF MORE TO DO
  
          GEN    (SA1 "HOLDX6") 
          GEN    (BX6 X1) 
          SB3    B3-60       DECREMENT LENGTH 
          SB2    B2+60       INCREMENT OFFSET 
          GT     B3,B0,GNRFTOP
  
  
* RESTORE REGISTERS AND EXIT
  
  
  
          SA1    SAVEB2 
          SB2    X1 
          SA1    SAVEB3 
          SB3    X1 
          SA1    SAVEB4 
          SB4    X1 
          SA4    SAVEX4 
  
  
          EXIT
 GNRF2    BSS    0           HANDLE LONG DISPLAY SUM FIELDS 
          GENMAC (VFD 12/0100B,18/=XSVR=,12/0,18/=XS$LREGS) 
  
*  THE ABOVE IS A GENERATED RJ TO SVR= WITH S$LREGS AS SAVE AREA
  
          GEN    (SX1 =XS$LREGS)
          GEN    (CALL XJR=)       RESTORE REGISTERS IMMEDIATELY
  
* THE NEXT CALL DESTROYS MOST REGISTERS IN THE GENERATED CODE 
  
          GEN    (CALL S$LNGSM) 
          GEN    (BX7 X1) 
          GEN    (SA7 =XS$NEWX1)
          GEN    (BX7 X2) 
          GEN    (SA7 =XS$NEWX2)
          GEN    (SX1 =XS$LREGS)
          GEN    (CALL XJR=)
  
* NOW PUT OUR GOOD STUFF INTO THE EXTERNAL RECORD 
  
          SA1    SAVEB3      LENGTH OF TOTAL EXTERNAL FIELD 
          SX2    60 
          IX2    X1-X2       EXTERNAL FIELD - 60
          SB5    X2          NUMBER OF EXTERNAL BITS IN S$NEWX1 
          GEN    (SA1 =XS$NEWX1)
  
          NEWLBL LAST 
          GEN    (SB5 B1)          FRONTPART := TRUE (NO DIGIT FOUND) 
          GEN    (SB6 0),B5        *B6 := NO. OF GOOD BITS IN *X1 
          SB7    60 
          SB7    B7-B5
          GEN    (LX1 0),B7        SHIFT AROUND IRRELEVANT BITS 
          GEN    (MX2 -6)          ONE-CHAR MASK
          NEWLBL SPACE
          NEWLBL RFLOOP 
          GENLBL RFLOOP 
          GEN    (LX1 6)
          GEN    (BX3 -X2*X1)      *ISOLATE CHAR IN *X3 
          GEN    (SB3 X3)          *CHAR NOW IN *B3 
          GEN    (SB6 B6-6)        DECREMENT COUNTER
          GEN    (EQ B6,B0,"LAST")
          GEN    (EQ B5,B0,"RFLOOP")
          GEN    (SB4 33B)   ZERO 
          GEN    (EQ B3,B4,"SPACE")    *SUBSTITUTE SPACE FOR ZERO 
  
* A DIGIT HAS BEEN FOUND
  
          GEN    (SB5 B0)          FRONTPART := FALSE 
          NEWLBL MINUS
          GEN    (NG X0,"MINUS")
          GEN    (EQ "RFLOOP")
  
          GENLBL SPACE
          GEN    (BX1 X1*X2)       ERASE THE ZERO 
          GEN    (SX3 55B)
          GEN    (BX1 X1+X3)
          GEN    (EQ "RFLOOP")
  
          GENLBL MINUS
          GEN    (LX1 -6) 
          GEN    (BX1 X1*X2)       ERASE PREVIOUS ZERO
          GEN    (SX3 46B)         MINUS SIGN 
          GEN    (BX1 X1+X3)       INSERT IT
          GEN    (LX1 6)           RETURN *X1 TO PROPER PLACE 
          GEN    (EQ "RFLOOP")
  
          NEWLBL NEXT2
          GENLBL LAST 
          NEWLBL NEXT 
          GEN    (NE B5,B1,"NEXT")   NO PROBLEM IF NOT FRONTPART
          GEN    (SB4 33B)
          NEWLBL EASY 
          GEN    (NE B4,B3,"EASY")   JUMP IF NON-ZERO 
          GEN    (BX1 X1*X2)         CHANGE ZERO TO SPACE 
          GEN    (SX3 55B)
          GEN    (BX1 X1+X3)
          NEWLBL EASIEST
          GEN    (EQ "EASIEST") 
  
          GENLBL EASY 
  
* WE HAVE DETECTED A NON-ZERO DIGIT 
  
          GEN    (MI X0,"NEXT2")     IF NEGATIVE NUMBER 
          GEN    (SB5 B0)            FRONTPART := FALSE 
  
          GENLBL EASIEST
          GEN    (PL X0,"NEXT")      NO PROBLEM IF POSITIVE 
          GEN    (NE B5,B1,"NEXT")   NO PROBLEM IF NOT FRONTPART
          GEN    (NE B4,B3,"NEXT2")  SPECIAL CASE IF LAST IS NZ 
  
* WE MAY HAVE A PROBLEM HERE. LAST CHARACTER OF *X1 IS ZERO 
* AND WE MAY HAVE A DIGIT IN THE NEXT WORD
* PROVISIONALLY CHANGE IT TO A SPACE AS USUAL 
  
          GEN    (BX1 X1*X2)         ERASE THE ZERO 
          GEN    (SX3 55B)
          GEN    (BX1 X1+X3)
  
          GEN    (SA4 =XS$NEWX2)
          GEN    (LX4 6)
          GEN    (BX7 -X2*X4) 
          GEN    (SB4 X7) 
          GEN    (SB4 B4-33B) 
          GEN    (EQ B4,B0,"NEXT")
  
* WE DO HAVE A DIGIT IN THE FIRST CHARACTER OF THE NEXT WORD, 
* AND THE NUMBER IS NEGATIVE
  
          GEN    (BX1 X1*X2)
          GEN    (SX3 46B)
          GEN    (BX1 X1+X3)
          GEN    (SB5 B0)      SET FRONTPART := FALSE 
          GEN    (EQ "NEXT")
  
          GENLBL NEXT2
  
* IN THIS CASE, THE LAST CHAR IS A DIGIT AND THE NUMBER IS NEGATIVE 
  
          GEN    (LX1 -6) 
          GEN    (BX1 X1*X2)   ERASE PREVIOUS ZERO
          GEN    (SX3 46B)     MINUS SIGN 
          GEN    (BX1 X1+X3)   INSERT IT
          GEN    (SB5 B0)      FRONTPART := FALSE 
          GEN    (LX1 6)       RETURN *X1 TO PROPER PLACE 
  
          GENLBL NEXT 
  
          GEN    (BX7 X1) 
          SX5    60 
          SX4    B5 
          IX5    X5-X4         OFFSET IN *X7 OF GOOD STUFF
          GEN    (BX4 X0)      *PRESERVE SIGN REGISTER IN *X4 
          CALL   S$GNRST
          GEN    (BX0 X4)      *RESTORE SIGN REGISTER 
* THAT WAS THE FIRST CLUMP. THE SECOND CLUMP IS ALWAYS 60 BITS
  
          SB2    B2+B5         INCREMENT THE OFFSET IN EXT REC
          SB5    60            ALWAYS 60 BITS 
          SX5    0             OFFSET ALWAYS ZERO SINCE REG IS FULL 
          GEN    (SA1 =XS$NEWX2)
          NEWLBL NEXT 
          GEN    (EQ B5,B0,"NEXT")
  
* STILL HUNTING FOR THE FIRST DIGIT, IT WOULD SEEM
          NEWLBL LAST 
          NEWLBL SPACE
          NEWLBL RFLOOP 
  
          GEN    (SB6 60) 
          GEN    (MX2 -6) 
          GENLBL RFLOOP 
          GEN    (LX1 6)
          GEN    (BX3 -X2*X1)   *ISOLATE CHAR IN *X3
          GEN    (SB3 X3)       *CHAR NOW IN *B3
          GEN    (SB6 B6-6)  DECREMENT COUNTER
          GEN    (EQ B6,B0,"LAST")
          GEN    (EQ B5,B0,"RFLOOP")
          GEN    (SB4 33B)   ZERO 
          GEN    (EQ B3,B4,"SPACE")    *SUBSTITUTE SPACE FOR ZERO 
  
* A DIGIT HAS BEEN FOUND
  
          GEN    (SB5 B0)              FRONTPART := FALSE 
          NEWLBL MINUS
          GEN    (NG X0,"MINUS")
          GEN    (EQ "RFLOOP")
  
          GENLBL SPACE
          GEN    (BX1 X1*X2) ERASE THE ZERO 
          GEN    (SX3 55B)
          GEN    (BX1 X1+X3)
          GEN    (EQ "RFLOOP")
  
          GENLBL MINUS
          GEN    (LX1 -6) 
          GEN    (BX1 X1*X2)         ERASE PREVIOUS ZERO
          GEN    (SX3 46B)           MINUS SIGN 
          GEN    (BX1 X1+X3)         INSERT IT
          GEN    (LX1 6)             RETURN *X1 TO PROPER PLACE 
          GEN    (EQ "RFLOOP")
  
          NEWLBL NEXT2
          GENLBL LAST 
          GEN    (SB4 33B)
          GEN    (PL X0,"NEXT")      NO PROBLEM IF POSITIVE 
          GEN    (NE B5,B1,"NEXT")   NO PROBLEM IF NOT FRONTPART
          GEN    (NE B4,B3,"NEXT2")  SPECIAL CASE IF LAST IS NZ 
  
* END CASE. NEGATIVE ZERO.
  
          GEN    (LX1 -6) 
          GEN    (BX1 X1*X2)
          GEN    (SX3 46B)
          GEN    (BX1 X1+X3)
          GEN    (LX1 6)
          GEN    (EQ "NEXT")
  
          GENLBL NEXT2
  
* IN THIS CASE, THE LAST CHAR IS A DIGIT AND THE NUMBER IS NEGATIVE 
  
          GEN    (LX1 -6) 
          GEN    (BX1 X1*X2)   ERASE PREVIOUS ZERO
          GEN    (SX3 46B)     MINUS SIGN 
          GEN    (BX1 X1+X3)   INSERT IT
          GEN    (LX1 6)       RETURN *X1 TO PROPER PLACE 
  
          GENLBL NEXT 
          GEN    (BX7 X1) 
          CALL   S$GNRST
          GEN    (SA1 "HOLDX6") 
          GEN    (BX6 X1) 
          SA1    SAVEB2 
          SB2    X1 
          SA1    SAVEB3 
          SB3    X1 
          SA1    SAVEB4 
          SB4    X1 
          SA4    SAVEX4 
  
          EXIT
  
  
  
SAVEB2    BSS    1           ORIGINAL VALUE OF B2 
  
SAVEB3    BSS    1           ORIGINAL VALUE OF B3 
  
SAVEB4    BSS    1           ORIGINAL VALUE OF B4 
  
SAVEB42   BSS    1           INTERMEDIATE B4 STORAGE
  
SAVEX4    BSS    1           ORIGINAL VALUE OF X4 
  
S$TBL1    EXTERNAL           TABLE OF BINARY LENGTHS OF NUMERICS
  
          END 
