anchor.diff:        (cond
          ((and
            (syntax-escape-char-p (preceding-char))
  -         (not (syntax-escape-char-p (two-preceding-char)))))
  +         (not (syntax-escape-char-p (char-before-2)))))
          ((not
            (or
             (syntax-escape-char-p c)
  
positive.code: (in-package :lem)
  
  (defun skip-chars-forward (pred &optional not-p)
    (do ()
        ((if (funcall pred (following-char))
           not-p
  
negative.code:     (unless (next-char 1)
        (return))))
  
  (defun skip-space-forward ()
    (skip-chars-forward 'syntax-space-char-p))
  
  (defun skip-space-backward ()
    (skip-chars-backward 'syntax-space-char-p))
  
  (defun skip-until-open-paren-forward ()
    (skip-chars-forward 'syntax-open-paren-char-p t))
  
  (defun skip-until-closed-paren-backward ()
    (skip-chars-backward 'syntax-closed-paren-char-p t))
  
  (define-dir-functions (forward-list-1 backward-list-1) ()
    ((skip-until-open-paren-forward skip-until-closed-paren-backward)
     (following-char preceding-char)
     (syntax-pair-closed-paren syntax-pair-open-paren)
     (preceding-char char-before-2)
     (char-before-2 char-before-3)
     (forward-list-1 backward-list-1)
     (prev-char next-char)
     (next-char prev-char)
     (skip-string-forward skip-string-backward))
    (skip-until-open-paren-forward)
    (let* ((paren-char (following-char))
           (goal-char (syntax-pair-closed-paren paren-char)))
      (do () (nil)
          (unless (next-char 1)
            (return))
        (unless (and (syntax-escape-char-p (preceding-char))
                  (not (syntax-escape-char-p (char-before-2))))
          (let ((c (following-char)))
            (cond
             ((eql c paren-char)
              (forward-list-1)
              (prev-char 1))
             ((eql c goal-char)
              (next-char 1)
              (return t))
             ((syntax-string-quote-char-p c)
              (skip-string-forward)
              (prev-char 1))))))))
  
  (define-key *global-keymap* "M-C-n" 'forward-list)
  (defcommand forward-list (n) ("p")
    (dotimes (_ n t)
      (unless (forward-list-1)
        (return))))
  
  (define-key *global-keymap* "M-C-p" 'backward-list)
  (defcommand backward-list (n) ("p")
    (dotimes (_ n t)
      (unless (backward-list-1)
        (return))))
  
  (define-dir-functions (skip-string-forward skip-string-backward) ()
    ((skip-chars-forward skip-chars-backward)
     (following-char preceding-char)
     (next-char prev-char)
     (preceding-char char-before-2)
     (char-before-2 char-before-3))
    (skip-chars-forward 'syntax-string-quote-char-p t)
    (let ((goal-char (following-char)))
      (do () (nil)
        (unless (next-char 1)
          (return))
        (unless (and (syntax-escape-char-p (preceding-char))
                     (not (syntax-escape-char-p (char-before-2))))
          (when (eql (following-char) goal-char)
            (next-char 1)
            (return t))))))
  
  (define-dir-functions (skip-symbol-forward skip-symbol-backward) ()
    ((next-char prev-char)
     (following-char preceding-char)
     (preceding-char char-before-2)
     (char-before-2 char-before-3))
    (do () (nil)
      (unless (next-char 1)
        (return))
  