anchor.diff:  
   (defun one-char ()
     (event-case (*display*)
  -    (:key-press (code state)
  -                (cond ((is-modifier code) (one-char))
  -                      ((sc= *abort* state code) *abort*)
  -                      ((sc= *this* state code) *this*)
  -                      (t (keycode->character *display* code state))))))
  +              (:key-press (code state)
  +                          (cond ((is-modifier code) (one-char))
  +                                ((sc= *abort* state code) *abort*)
  +                                ((sc= *this* state code) *this*)
  +                                (t (keycode->character *display* code state))))))
   
   (defun recdo (pos list fn)
     (cond ((null list))
  
positive.code:   (let ((focus (input-focus *display*)))
      (when (win= focus *curr*)
        (send-event focus :key-press (make-event-mask :key-press)
                    :window focus
                    :code (code *prefix*)
                    :state (state *prefix*)))))
  (defshortcut (#\t) (send-prefix))
  
  ;;; Main
  (defun main ()
    (let (last-button last-x last-y waiting-shortcut last-resize)
  
      ;; Grab prefix and mouse buttons on root
      (grab-key *root* (code *prefix*) :modifiers (state *prefix*))
      (grab-button *root* (code *move*) '(:button-press) :modifiers (state *move*))
      (grab-button *root* (code *resize*) '(:button-press) :modifiers (state *resize*))
      (grab-button *root* (code *close*) '(:button-press) :modifiers (state *close*))
  
      ;; Populate list of windows
      (dolist (w (query-tree *root*))
        (when (and (eql (window-map-state w) :viewable)
                   (eql (window-override-redirect w) :off))
          (plus w)))
  
      (intern-atom *display* :_motif_wm_hints)
      (setf (window-event-mask *root*) '(:substructure-notify))
  
      (unwind-protect
           (loop do
                (event-case
                 (*display* :discard-p t)
                 (:key-press
                  (code state)
                  (unless (is-modifier code)
                    (cond (waiting-shortcut
                           (let ((entry (assoc-if
                                         #'(lambda (sc) (sc= sc state code)) *shortcuts*)))
                             (when entry
                               (let ((fn (cdr entry)))
                                 (cond ((functionp fn) (funcall fn))
                                       ((eq fn 'quit) (loop-finish))))))
                           (ungrab-keyboard *display*)
                           (setf waiting-shortcut nil))
                          ((sc= *prefix* state code)
                           (grab-keyboard *root*)
                           (setf waiting-shortcut t)))))
                 (:button-press
                  (code state child)
                  (when (and child (eql (window-override-redirect child) :off))
                    (cond ((sc= *close* state code)
                           (send-message child :WM_PROTOCOLS
                                         (intern-atom *display* :WM_DELETE_WINDOW)))
                          (t
                           (setf last-button code)
                           (focus (find child *windows* :test #'win=))
                           (grab-pointer child '(:pointer-motion :button-release))
                           (when (sc= *resize* state code)
                             (warp-pointer child (drawable-width child)
                                           (drawable-height child)))
                           (let ((lst (multiple-value-list (query-pointer *root*))))
                             (setf last-x (sixth lst)
                                   last-y (seventh lst)))))))
                 (:motion-notify
                  (event-window root-x root-y time)
                  (cond ((= last-button (code *move*))
                         (let ((delta-x (- root-x last-x))
                               (delta-y (- root-y last-y)))
                           (incf (drawable-x event-window) delta-x)
                           (incf (drawable-y event-window) delta-y)
                           (incf last-x delta-x)
                           (incf last-y delta-y)))
                        ((= last-button (code *resize*))
                         (when (or (null last-resize) (> (- time last-resize) (/ 1000 60)))
                           (let ((new-w (max 1 (- root-x (drawable-x event-window))))
                                 (new-h (max 1 (- root-y (drawable-y event-window)))))
                             (setf (drawable-width event-window) new-w
                                   (drawable-height event-window) new-h))
                           (setf last-resize time)))))
                 (:button-release () (ungrab-pointer *display*))
                 (:map-notify
                  (window override-redirect-p)
                  (unless override-redirect-p
                    (focus (plus window))))
                 (:unmap-notify
                  (window)
                  (focus (minus window)))))
        (ungrab-button *root* (code *move*) :modifiers (state *move*))
        (ungrab-button *root* (code *resize*) :modifiers (state *resize*))
        (ungrab-button *root* (code *close*) :modifiers (state *close*))
        (ungrab-key *root* (code *prefix*) :modifiers (state *prefix*))
        (close-display *display*))))
  
  (main)
  
negative.code: 
  (defun send-message (window type &rest data)
    (send-event window :client-message nil :window window
                       :type type :format 32 :data data))
  
  ;;; Apps in path
  (defun split-string (string &optional (character #\Space))
    "Returns a list of substrings of string
  divided by ONE space each.
  Note: Two consecutive spaces will be seen as
  if there were an empty string between them."
    (loop for i = 0 then (1+ j)
          as j = (position character string :start i)
          collect (subseq string i j)
          while j))
  
  (defun execp (pathname)
    "Return T if the pathname describes an executable file."
  