anchor.diff:  
   (defun print-integer (n)
     (declare (integer n))
  -  (if (zerop n)
  -      #.(make-array 1 :element-type '(unsigned-byte 8) :initial-element (char-code #\0))
  -      (let ((sign nil))
  -        (when (minusp n)
  -          (setf sign t
  -                n (- n)))
  -        (let ((length
  -               (loop for i of-type integer = n then (floor i 10) while (plusp i) count t))
  -              bytes)
  -          (when sign
  -            (incf length))
  -          (setf bytes (make-array length :element-type '(unsigned-byte 8)))
  -          (do ((p (1- length) (1- p)))
  -              ((zerop n))
  -            (multiple-value-bind (div mod)
  -                (floor n 10)
  -              (setf (aref bytes p) (+ mod #.(char-code #\0))
  -                    n div)))
  -          (when sign
  -            (setf (aref bytes 0) #.(char-code #\-)))
  -          bytes))))
  +  (macrolet ((specialized-integer (type)
  +               `(let ((sign nil))
  +                  (declare (,type n))
  +                  (when (minusp n)
  +                    (setf sign t
  +                          n (- n)))
  +                  (let ((length
  +                         (loop for i of-type ,type = n then (truncate i 10) while (plusp i) count t))
  +                        bytes)
  +                    (declare (,type length))
  +                    (when sign
  +                      (incf length))
  +                    (setf bytes (make-array length :element-type '(unsigned-byte 8)))
  +                    (do ((p (1- length) (1- p)))
  +                        ((zerop n))
  +                      (multiple-value-bind (div mod)
  +                          (truncate n 10)
  +                        (setf (aref bytes p) (+ mod #.(char-code #\0))
  +                              n div)))
  +                    (when sign
  +                      (setf (aref bytes 0) #.(char-code #\-)))
  +                    bytes))))
  +    (cond
  +      ((zerop n)
  +       #.(make-array 1 :element-type '(unsigned-byte 8) :initial-element (char-code #\0)))
  +      ((typep n 'fixnum)
  +       (specialized-integer fixnum))
  +      ((typep n '(signed-byte 64))
  +       (specialized-integer (signed-byte 64)))
  +      (t
  +       (specialized-integer integer)))))
   
   (defun make-tnetstring (type args)
     (declare ((unsigned-byte 8) type)
              (list args))
  -  (let* ((length (the fixnum (reduce #'+ args :key #'length)))
  +  (let* ((length (the fixnum (loop for arg in args sum (length arg))))
            (prefix (print-integer length))
            (total (+ length (length prefix) 2))
            (bytes (make-array total :element-type '(unsigned-byte 8)))
  
positive.code:     (setf (aref bytes pos) type)
      bytes))
  
  (defmethod dump-tnetstring ((data (eql nil)))
    #.(babel:string-to-octets "0:~"))
  
  (defmethod dump-tnetstring ((data (eql t)))
    #.(babel:string-to-octets "4:true!"))
  
  (defmethod dump-tnetstring ((data float))
    (make-tnetstring
     #.(char-code #\^)
     (list (babel:string-to-octets (princ-to-string data)))))
  
  (defmethod dump-tnetstring ((data hash-table))
    (make-tnetstring
     #.(char-code #\})
     (loop
        for key being the hash-keys of data using (hash-value val)
        nconc (list (dump-tnetstring key)
                    (dump-tnetstring val)))))
  
  (defmethod dump-tnetstring ((data integer))
    (make-tnetstring
     #.(char-code #\#)
     (list (print-integer data))))
  
  (defmethod dump-tnetstring ((data list))
    (if (and (consp (car data))
             (keywordp (caar data)))
        (make-tnetstring
         #.(char-code #\})
         (loop
            for (key . val) in data
            nconc (list (dump-tnetstring key)
                        (dump-tnetstring val))))
        (make-tnetstring
         #.(char-code #\])
         (mapcar #'dump-tnetstring data))))
  
  (defmethod dump-tnetstring ((data string))
    (dump-tnetstring (babel:string-to-octets data)))
  
  (defmethod dump-tnetstring ((data symbol))
    (dump-tnetstring (symbol-name data)))
  
  (defmethod dump-tnetstring ((data vector))
    (make-tnetstring #.(char-code #\,) (list data)))
  
  (defparameter *tests* 
    (list (list (babel:string-to-octets "0:}") nil)
  
negative.code:      with length of-type fixnum = 0
       when (eq b #.(char-code #\:)) return (values length (1+ i))
       do (setf length
                (+ (the fixnum (ash length 3)) (ash length 1)
                   (- b #.(char-code #\0))))
       finally (return (values nil nil))))
  
  (defmacro parsing ((bytes start end) &body body)
    (once-only (bytes start end)
      (with-unique-names (value position pos)
        `(let ((,position ,start))
           (flet ((next-tnetstring ()
                    (multiple-value-bind (,value ,pos)
                        (parse-tnetstring ,bytes ,position ,end)
                      (setf ,position ,pos)
                      ,value)))
             ,@body)))))
  
  (defun parse-tnetstring (bytes &optional (start 0) (end (length bytes)))
    (declare ((simple-array (unsigned-byte 8)) bytes)
  