anchor.diff:                  :for offset := (parse-ex-offset lexer)
                   :collect line
                   :when offset :collect it
  -                :unless (and (eq :search (first line))
  +                :unless (and (member (first line)
  +                                     '(lem-vi-mode.ex-command:search-forward
  +                                       lem-vi-mode.ex-command:search-backward))
                                (setf line (match-pattern lexer)))
                   :do (loop-finish))))
       (if (alexandria:length= list 1)
           (first list)
  -        (cons :patterns list))))
  +        `(progn . ,list))))
   
   (defun delimiter (lexer)
     (unless (end-of-string-p lexer)
       (cond ((accept lexer #\,)
              (values nil t))
             ((accept lexer #\;)
  -           (values :goto t))
  +           (values 'lem-vi-mode.ex-command:goto-current-point t))
             (t
              (values nil nil)))))
   
  -(defun parse-ex-range (string)
  -  (let ((lexer (make-lexer :position 0 :string string))
  -        (range '()))
  +(defun parse-ex-range (lexer)
  +  (let ((range '()))
       (loop :with delim := nil :and contp := nil
  -          :do (push (parse-ex-range-element lexer) range)
  +          :for elt := (parse-ex-range-element lexer)
  +          :do (when elt (push elt range))
                 (setf (values delim contp) (delimiter lexer))
                 (unless contp (return))
  -          (when delim
  -            (setf (first range) (list :goto (first range)))))
  -    (nreverse range)))
  +              (when delim
  +                (setf (first range) (list delim (first range)))))
  +    (when range
  +      `(lem-vi-mode.ex-command:range . ,(nreverse range)))))
  +
  +(defun parse-ex (lexer)
  +  (let ((range (parse-ex-range lexer)))
  +    ))
  
positive.code: (defun match-pattern (lexer)
    (unless (end-of-string-p lexer)
      (alexandria:when-let ((result (match-pattern-1 lexer #\/)))
        (return-from match-pattern (list :search :forward result)))
      (alexandria:when-let ((result (match-pattern-1 lexer #\?)))
        (return-from match-pattern (list :search :backward result)))))
  
  (defun parse-ex-line (lexer)
    (skip-whitespace lexer)
    (unless (end-of-string-p lexer)
      (let ((result))
        (cond ((setf result (match-number lexer))
               (list :line-number result))
              ((setf result (case (lookahead lexer)
                              (#\. :current-line)
                              (#\$ :last-line)
                              (#\% :all-lines)))
               (lexer-forward lexer)
               (list result))
              ((accept lexer #\')
               (prog1 (list :mark (lookahead lexer))
                 (lexer-forward lexer)))
              ((match-pattern lexer))))))
  
  
negative.code:   (unless (end-of-string-p lexer)
      (cond ((accept lexer #\+)
             (alexandria:when-let ((number (match-number lexer)))
               `(lem-vi-mode.ex-command:offset-line ,number)))
            ((accept lexer #\-)
             (alexandria:when-let ((number (match-number lexer)))
               `(lem-vi-mode.ex-command:offset-line ,(- number)))))))
  
  (defun parse-ex-range-element (lexer)
    (let ((list (loop
  