anchor.diff:                      (make-string (* n *tab-size*) :initial-element #\space))))
   
   (defun blank-line-p ()
  -  (let ((string (buffer-line-string (current-buffer) (window-current-linum)))
  -        (eof-p (buffer-end-line-p (current-buffer) (window-current-linum))))
  +  (let ((string (buffer-line-string (current-buffer) (current-linum)))
  +        (eof-p (buffer-end-line-p (current-buffer) (current-linum))))
       (when (string= "" (string-trim '(#\space #\tab) string))
         (+ (length string)
            (if eof-p 0 1)))))
  
positive.code:   (let ((buffer (current-buffer)))
      (when (buffer-check-marked buffer)
        (psetf
         (window-current-linum) (marker-linum (buffer-mark-marker buffer))
         (window-current-charpos) (marker-charpos (buffer-mark-marker buffer))
         (marker-linum (buffer-mark-marker buffer)) (window-current-linum)
         (marker-charpos (buffer-mark-marker buffer)) (window-current-charpos))
        (assert (<= 0 (window-current-charpos)))
        t)))
  
  (defun following-char ()
    (buffer-get-char (current-buffer)
                     (window-current-linum)
                     (window-current-charpos)))
  
  (defun preceding-char ()
    (cond
     ((bobp)
      nil)
     ((bolp)
      (buffer-get-char (current-buffer)
                       (1- (window-current-linum))
                       (buffer-line-length (current-buffer)
                                           (1- (window-current-linum)))))
     (t
      (buffer-get-char (current-buffer)
                       (window-current-linum)
                       (1- (window-current-charpos))))))
  
  (defun char-after (&optional (n 0))
    (if (zerop n)
  
negative.code: (define-key *global-keymap* (kbd "[dc]") 'delete-char)
  (define-command delete-char (&optional n does-not-kill-p) ("P")
    (cond
      ((and n (minusp n))
       (backward-delete-char (- n)))
      ((eobp) nil)
      (t
       (let ((lines
               (buffer-delete-char (current-buffer)
                                   (current-linum)
                                   (current-charpos)
                                   (or n 1))))
         (when (and (not does-not-kill-p) n)
           (with-kill ()
             (kill-push lines)))
         t))))
  
  (define-key *global-keymap* (kbd "C-h") 'backward-delete-char)
  (define-key *global-keymap* (kbd "[backspace]") 'backward-delete-char)
  