anchor.diff:    (%skip-quote-backward point))
   
   (defun %skip-list-forward (point depth)
  -  (loop :with paren-stack := '() :do
  -     (unless (skip-space-and-comment-forward point)
  -       (return nil))
  -     (when (end-buffer-p point)
  -       (return nil))
  -     (let ((c (character-at point 0)))
  -       (cond ((syntax-open-paren-char-p c)
  -	      (push c paren-stack)
  -	      (character-offset point 1)
  -	      (when (zerop (incf depth))
  -		(return point)))
  -	     ((syntax-closed-paren-char-p c)
  -	      (unless (or (and (< 0 depth)
  -			       (null paren-stack))
  -			  (syntax-equal-paren-p c (car paren-stack)))
  -		(return nil))
  -	      (pop paren-stack)
  -	      (character-offset point 1)
  -	      (when (zerop (decf depth))
  -		(return point)))
  -	     ((syntax-string-quote-char-p c)
  -	      (%skip-string-forward point))
  -             ((syntax-fence-char-p c)
  -              (%skip-fence-forward point))
  -	     ((syntax-escape-char-p c)
  -              (unless (character-offset point 2)
  -                (return nil)))
  -	     (t
  -	      (character-offset point 1))))))
  +  (loop :with paren-stack := '()
  +        :do
  +        (unless (skip-space-and-comment-forward point)
  +          (return nil))
  +        (when (end-buffer-p point)
  +          (return nil))
  +        (let ((c (character-at point 0))
  +              n pair)
  +          (cond ((syntax-open-paren-char-p c)
  +                 (push c paren-stack)
  +                 (character-offset point 1)
  +                 (when (zerop (incf depth))
  +                   (return point)))
  +                ((syntax-closed-paren-char-p c)
  +                 (unless (or (and (< 0 depth)
  +                                  (null paren-stack))
  +                             (syntax-equal-paren-p c (car paren-stack)))
  +                   (return nil))
  +                 (pop paren-stack)
  +                 (character-offset point 1)
  +                 (when (zerop (decf depth))
  +                   (return point)))
  +                ((multiple-value-setq (n pair) (syntax-start-block-string-p point))
  +                 (character-offset point n)
  +                 (unless (search-forward point (cdr pair))
  +                   (return nil)))
  +                ((syntax-string-quote-char-p c)
  +                 (%skip-string-forward point))
  +                ((syntax-fence-char-p c)
  +                 (%skip-fence-forward point))
  +                ((syntax-escape-char-p c)
  +                 (unless (character-offset point 2)
  +                   (return nil)))
  +                (t
  +                 (character-offset point 1))))))
   
   (defun %skip-list-backward (point depth)
  -  (loop :with paren-stack := '() :do
  -     (unless (skip-space-and-comment-backward point)
  -       (return nil))
  -     (when (start-buffer-p point)
  -       (return nil))
  -     (let ((c (character-at point -1)))
  -       (cond ((syntax-escape-point-p point -1)
  -	      (character-offset point -1))
  -	     ((syntax-closed-paren-char-p c)
  -	      (push c paren-stack)
  -	      (character-offset point -1)
  -	      (when (zerop (incf depth))
  -		(return point)))
  -	     ((syntax-open-paren-char-p c)
  -	      (unless (or (and (< 0 depth)
  -			       (null paren-stack))
  -			  (syntax-equal-paren-p c (car paren-stack)))
  -		(return nil))
  -	      (pop paren-stack)
  -	      (character-offset point -1)
  -	      (when (zerop (decf depth))
  -		(return point)))
  -	     ((syntax-string-quote-char-p c)
  -	      (%skip-string-backward point))
  -             ((syntax-fence-char-p c)
  -              (%skip-fence-backward point))
  -	     (t
  -	      (character-offset point -1))))))
  +  (loop :with paren-stack := '()
  +        :do
  +        (unless (skip-space-and-comment-backward point)
  +          (return nil))
  +        (when (start-buffer-p point)
  +          (return nil))
  +        (let ((c (character-at point -1))
  +              n pair)
  +          (cond ((syntax-escape-point-p point -1)
  +                 (character-offset point -1))
  +                ((syntax-closed-paren-char-p c)
  +                 (push c paren-stack)
  +                 (character-offset point -1)
  +                 (when (zerop (incf depth))
  +                   (return point)))
  +                ((syntax-open-paren-char-p c)
  +                 (unless (or (and (< 0 depth)
  +                                  (null paren-stack))
  +                             (syntax-equal-paren-p c (car paren-stack)))
  +                   (return nil))
  +                 (pop paren-stack)
  +                 (character-offset point -1)
  +                 (when (zerop (decf depth))
  +                   (return point)))
  +                ((multiple-value-setq (n pair) (syntax-end-block-string-p point))
  +                 (character-offset point (- n))
  +                 (unless (search-backward point (car pair))
  +                   (return nil)))
  +                ((syntax-string-quote-char-p c)
  +                 (%skip-string-backward point))
  +                ((syntax-fence-char-p c)
  +                 (%skip-fence-backward point))
  +                (t
  +                 (character-offset point -1))))))
   
   (defun %form-offset-positive (point)
     (skip-space-and-comment-forward point)
  
positive.code:   (skip-space-and-comment-backward point)
    (when (start-buffer-p point)
      (return-from %form-offset-negative nil))
    (let ((c (character-at point -1)))
      (prog1 (cond ((or (syntax-symbol-char-p c)
                        (syntax-escape-char-p c)
                        (syntax-expr-prefix-char-p c)
  
negative.code:                 (parser-state-token-start-point state) token-start-point
                  (parser-state-end-char state) end-char
                  (parser-state-block-comment-depth state) block-comment-depth
                  (parser-state-block-pair state) block-pair
                  (parser-state-paren-stack state) paren-stack))
          state))))
  
  