anchor.diff:      (do () (nil)
         (unless (prev-char 1)
           (return))
  -      (when (and
  -             (not (syntax-escape-char-p (two-preceding-char)))
  -             (char= (preceding-char) goal-char))
  -        (prev-char 1)
  -        (return t)))))
  +      (unless (and (syntax-escape-char-p (two-preceding-char))
  +                   (not (syntax-escape-char-p (three-preceding-char))))
  +        (when (char= (preceding-char) goal-char)
  +          (prev-char 1)
  +          (return t))))))
   
   (defun skip-symbol-forward ()
     (do () (nil)
       (unless (next-char 1)
         (return))
       (let ((c (following-char)))
  -      (unless (or (syntax-symbol-char-p c)
  -                  (syntax-word-char-p c))
  -        (return t)))))
  +      (cond
  +       ((and
  +         (syntax-escape-char-p (preceding-char))
  +         (not (syntax-escape-char-p (two-preceding-char)))))
  +       ((not
  +         (or
  +          (syntax-escape-char-p c)
  +          (syntax-symbol-char-p c)
  +          (syntax-word-char-p c)))
  +        (return t))))))
   
   (defun skip-symbol-backward ()
     (do () (nil)
       (unless (prev-char 1)
         (return))
       (let ((c (preceding-char)))
  -      (unless (or (syntax-symbol-char-p c)
  -                  (syntax-word-char-p c))
  -        (return t)))))
  +      (cond
  +       ((and
  +         (syntax-escape-char-p (two-preceding-char))
  +         (not (syntax-escape-char-p (three-preceding-char)))))
  +       ((not
  +         (or
  +          (syntax-escape-char-p c)
  +          (syntax-symbol-char-p c)
  +          (syntax-word-char-p c)))
  +        (return t))))))
   
   (define-key *global-keymap* "M-C-f" 'forward-sexp)
   (defcommand forward-sexp (n) ("p")
  
positive.code:     (do () (nil)
        (unless (next-char 1)
          (return))
        (when (and
               (not (syntax-escape-char-p (preceding-char)))
               (char= (following-char) goal-char))
          (next-char 1)
          (return t)))))
  
  (defun skip-string-backward ()
    (skip-chars-backward 'syntax-string-quote-char-p t)
  
negative.code:     (prog1 (preceding-char)
        (next-char 1))))
  
  (defun three-preceding-char ()
    (when (prev-char 2)
      (prog1 (preceding-char)
        (next-char 2))))
  
  (define-key *global-keymap* "M-C-n" 'forward-list)
  (defcommand forward-list (&optional (n 1)) ("p")
    (dotimes (_ n t)
  