anchor.diff:  (defun next-directive (start end)
     (let (i j ii k count c close
           (pairs '((#\( . #\)) (#\[ . #\]) (#\< . #\>) (#\{ . #\}))))
  -    (multiple-value-setf (i j) (next-directive1 start end))
  +    (setf (values i j) (next-directive1 start end))
       (when i
         (setf c (aref *string* j))
         (setf close (cdr (assoc c pairs)))
         (when close
           (setf k j count 0)
           (loop
  -          (multiple-value-setf (ii k) (next-directive1 k end))
  +          (setf (values ii k) (next-directive1 k end))
             (when (null ii) (err 4 "No matching close directive" j))
             (when (eql (aref *string* k) c) (incf count))
             (when (eql (aref *string* k) close) (decf count)
  
positive.code: (defun num-args-in-directive (start end)
    (let ((n 0) c i j)
      (incf n (num-args-in-args start T))
      (multiple-value-setf (j i) (next-directive1 start end))
      (loop
        (multiple-value-setf (c i j) (next-directive j end))
        (when (null c) (return n))
        (cond ((eql c #\;)
               (if (colonp j)
  
negative.code: (defun compile-format (start end)
    (let ((result nil))
      (prog (c i j fn)
       L(setf (values c i j) (next-directive start end))
        (when (if (null c) (< start end) (< start i))
          (push (literal start (if i i end)) result))
        (when (null c) (return (nreverse result)))
  