anchor.diff:             ((= token-type 'Quote); quote
                   (extend buff (string  "'")))
              ((= token-type 'Comment) ; comment
  -                (extend buff (string (last element) "\n")))
  +                (extend buff (string (last element) )))
              ((= token-type 'Integer) ; int
                   (extend buff (string (int (last element)))))
              ((= token-type 'Float) ; float
                   (extend buff (string (precise-float (last element)))))  
              ((= token-type 'Scientific) ; scientific notation
  -                (extend buff (scientific-float (last element))))  
  +                (extend buff (scientific-float (last element))))
  +           ((= token-type 'BigintLit) ; these have "L" appended
  +                (extend buff (string (bigint (last element)))))  
  +           ((= token-type 'Bigint) ; these are implicit bignums
  +                (extend buff (trim (string (bigint (last element))) "L")))  
              ((= token-type 'BracketedCommand) ; bracketed command
                  (extend buff (string {[cmd]} (last element) {[/cmd]})))
              ((or 
                   (= token-type 'Symbol) ; close parenthesis
                   (= token-type 'Hex) ; hex
  -                (= token-type 'NaN) ; not a number
  +                (= token-type 'NaN) ; some generic number
                   (= token-type 'Octal) ; octal
                   )
                   (extend buff (string (last element))))
  
positive.code:   (let ((res '() number-as-string ""))
       (set 'number-as-string (join (read-number-scanner (list c))))
       (cond
         ; try hex first
         ((starts-with (lower-case number-as-string) "0x")
            (set 'res  (list 'Hex number-as-string)))
         ; scientific notation if there's an e
         ((find "e" (lower-case number-as-string))
            (set 'res  (list 'Scientific (scientific-float number-as-string))))
         ; float?
         ((find "." number-as-string)
            ; newLISP's float function isn't quite what we want here     
            (set 'res  (list 'Float (precise-float number-as-string))))
         ; octal, not hex or float? 017 is OK, 019 is read as 10
         ((and (starts-with (lower-case number-as-string) "0") 
               (> (length number-as-string) 1)
               (empty? (difference (explode number-as-string) (explode "01234567"))))
            (set 'res (list 'Octal number-as-string)))
         ; perhaps an integer?  019 is read as 19 ...
         ((integer? (int number-as-string 0 10))
           (set 'res  (list 'Integer (int number-as-string 0 10))))
         ; give up
         (true
           (set 'res (list 'NaN "NaN"))))
    (add-to-parse-tree res)))
  
  (define (read-quote)
  
negative.code: ;; @author cormullion
  ;; @description  newLISP source code lexer/tokenizer/parser
  ;; @location somewhere on github
  ;; @version 0.2 of 2014-01-05 17:30:10 (bigint handling added)
  ;;<h4>About this module</h4>
  ;;<p>The Nlex module is a lexer/tokenizer/parser for newLISP source code.
  ;; An expert from StackOverflow xplains:
  