anchor.diff:                         (with (first-char (if (= (string/char-at a 3) "-")
                                              (progn (.<! val :sign true) 4)
                                              3))
  -                         (for i 0 (floor (/ (- (#s a) first-char) (/ part-bits size))) 1
  -                           (let* [(end-pos (- (#s a) (* i (/ part-bits size))))
  +                         (for i 0 (floor (/ (- (# a) first-char) (/ part-bits size))) 1
  +                           (let* [(end-pos (- (# a) (* i (/ part-bits size))))
                                     (start-upos (- end-pos (- (/ part-bits size) 1)))
                                     (start-pos (if (< start-upos first-char) first-char start-upos))
                                     (p (tonumber (string/sub a start-pos end-pos) base))]
  
positive.code:                        (string/concat (reverse parts)))]))]
      (while (= (string/char-at str 1) "0")
        (set! str (string/sub str 2)))
      (when (= (#s str) 0)
        (set! str "0"))
      (.. (if (.> a :sign) "-" "") (string/rep "0" (- digits (#s str))) str)))
  
  
  (defun equals? (a b)
  
negative.code:    'X' (uppercase hex),
     'o' (octal), or
     'b' (binary)."
    (let* [(type (if (> (# (or format "")) 0)
                   (string/char-at format (# format))
                   "d"))
           (digits (if (> (# (or format "")) 1) (tonumber (string/sub format 1 -2)) 0))
           (num->string (lambda (base size symbol)
                          (with (str (concat (reverse (map
                                                        (lambda (n)
  