anchor.diff:       with length of-type fixnum = 0
        when (eq b #.(char-code #\:)) return (values length (1+ i))
        do (setf length
  -              (+ (* length 10)
  -                 (- b (char-code #\0))))
  -     finally (return nil)))
  +              (+ (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)
  
positive.code: 
  (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))))
  
  (defun make-tnetstring (type args)
    (declare ((unsigned-byte 8) type)
             (list args))
    (let* ((length (the fixnum (reduce #'+ args :key #'length)))
           (prefix (print-integer length))
           (total (+ length (length prefix) 2))
           (bytes (make-array total :element-type '(unsigned-byte 8)))
  
negative.code:     (declare ((or null fixnum) length start))
      (if (or (null length)
              (> (+ start length) end))
          (values 'eof nil)
          (let* ((end (+ start length))
                 (next (1+ end))
                 (payload-type (aref bytes end)))
  