anchor.diff:  (define-key *global-keymap* (kbd "C-k") 'kill-line)
   (define-command kill-line (&optional n) ("P")
     (cond
  -   ((null n)
  -    (delete-char
  -     (cond ((eolp) 1)
  -           ((blank-line-p))
  -           (t (- (buffer-line-length (current-buffer)
  -                                     (window-current-linum))
  -                 (window-current-charpos))))))
  -   ((plusp n)
  -    (dotimes (_ n)
  -      (kill-line)))))
  +    ((null n)
  +     (delete-char
  +      (cond ((eolp) 1)
  +            ((blank-line-p))
  +            (t (- (buffer-line-length (current-buffer)
  +                                      (current-linum))
  +                  (current-charpos))))))
  +    ((plusp n)
  +     (dotimes (_ n)
  +       (kill-line)))))
   
   (defun set-charpos (pos)
     (assert (<= 0 pos))
  -  (setf (window-current-charpos) pos))
  +  (setf (current-charpos) pos))
   
   (define-key *global-keymap* (kbd "C-a") 'beginning-of-line)
   (define-key *global-keymap* (kbd "[home]") 'beginning-of-line)
  
positive.code:           (delete-char 1 (not use-kill-ring))))))
  
  (macrolet ((def (name at-char step-char)
                  `(defun ,name (pred &optional not-p)
                     (do ()
                         ((not (if (if (or (functionp pred)
                                           (symbolp pred))
                                       (funcall pred (,at-char))
                                       (find (,at-char) pred))
                                   (not not-p)
                                   not-p))
                          t)
                       (unless (,step-char)
                         (return))))))
    (def skip-chars-forward following-char next-char)
    (def skip-chars-backward preceding-char prev-char))
  
  
negative.code:   (beginning-of-line)
    (if (plusp n)
        (dotimes (_ n t)
          (when (tail-line-p)
            (end-of-line)
            (return))
          (incf (current-linum)))
        (dotimes (_ (- n) t)
          (when (head-line-p)
            (return))
          (decf (current-linum)))))
  
  (let ((tmp-column))
    (defun %next-line-before ()
      (when-interrupted-flag :next-line
                             (setq tmp-column
                                   (str-width (buffer-line-string
                                               (current-buffer)
                                               (current-linum))
                                              0
                                              (current-charpos)))))
    (defun %next-line-after ()
      (let ((pos (or (wide-index (buffer-line-string
                                  (current-buffer)
                                  (current-linum))
                                 tmp-column)
                     (buffer-line-length
                      (current-buffer)
                      (current-linum)))))
        (when pos
          (setf (current-charpos) pos)))
      (check-type (current-charpos)
                  (integer 0 #.most-positive-fixnum))))
  
  (define-key *global-keymap* (kbd "C-n") 'next-line)
  