anchor.diff:                    (%skip-list-backward point 0))
                    ((syntax-open-paren-char-p c)
                     nil)
  +                 ((multiple-value-setq (n pair) (syntax-end-block-string-p point))
  +                  (character-offset point (- n))
  +                  (if (search-backward point (car pair))
  +                      point
  +                      nil))
                    ((syntax-string-quote-char-p c)
                     (%skip-string-backward point))
                    ((syntax-fence-char-p c)
  
positive.code:   (%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))))))
  
  (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))))))
  
  (defun %form-offset-positive (point)
    (skip-space-and-comment-forward point)
  
negative.code:   expr-prefix-backward-function
    line-comment-string
    block-comment-pairs
    block-string-pairs
    region-list
    match-list)
  
  