anchor.diff:                           ,(comseq-construct-form prior-coms)
                            ,(comseq-construct-form post-coms))))
   
  -;;; COMSEQ-CONSTRUCT-FORM, COM-STRINGIFY-FORM and COMITEM-STRINGIFY-FORM return
  +;;; COMSEQ-CONSTRUCT-FORM, COM-EVALARGIFY-FORM and COMITEM-STRINGIFY-FORM return
   ;;; a form that returns one string if evaluated. A function that returns a form
   ;;; is of course quite natural when we are writing macros. What I want to
   ;;; emphasize here is, do not use it in a function definition. It works in
  
positive.code: (defun state-arrive-desc (state)
    (case state
      (raw "")
      (screen (seval-arg "command"))
      (t (seval-arg (concat-str "command -c " (resolve-string state))))))
  
  (defun spacing-join (&rest strs)
    (format nil "~{~a~^ ~}" strs))
  
  ;;; desc : string
  ;;; state : string-designator
  ;;; key : string or an integer number or a character. Symbol is NOT allowed.
  ;;;       How to treat octal numbers?
  
  ;(defun keybind-desc (key start-state goal-state prior-comdescs post-comdescs)
  ;  (string-trim " "
  ;               (spacing-join (state-leave-desc start-state)
  ;                             (resolve-string key)
  ;                             "eval"
  ;                             (apply #'spacing-join (mapcar #'seval-arg prior-comdescs))
  ;                             (state-arrive-desc goal-state)
  ;                             (apply #'spacing-join (mapcar #'seval-arg post-comdescs)))))
  
  (defun keybind-desc (key start-state goal-state prior-comdescs post-comdescs)
    (string-trim " "
                 (spacing-join (state-leave-desc start-state)
                               (resolve-string key)
                               "eval"
                               (if (or (null prior-comdescs)
                                       (and (null (cdr prior-comdescs))
                                            (zerop (length (car prior-comdescs)))))
                                 ""
                                 (apply #'spacing-join (mapcar #'seval-arg prior-comdescs)))
                               (state-arrive-desc goal-state)
                               (if (or (null post-comdescs)
                                       (and (null (cdr post-comdescs))
                                            (zerop (length (car post-comdescs)))))
                                 ""
                                 (apply #'spacing-join (mapcar #'seval-arg post-comdescs))))))
  
  (keybind-desc #\C 'screen "X"
                (list "split -v" "focus right" "other" "focus left")
                (list "echo \"enter [X]\""))
  
  (keybind-desc 'c 'screen "X"
                (list "split -v" "focus right" "other" "focus left")
                (list "echo \"enter [X]\""))
  
  (keybind-desc "^v" 'screen "X"
                (list "split -v" "focus right" "other" "focus left")
                (list "echo \"enter [X]\""))
  
  (keybind-desc "v" "X" "X"
                (list "split -v" "focus right" "other" "focus left")
                (list "echo \"enter [X]\""))
  
  (keybind-desc "^s" "X" "X"
                (list "split" "focus down" "other" "focus up")
                (list "echo \"enter [X]\""))
  
  (keybind-desc "v" "X" "X"
                (list "split -v" "focus right" "other" "focus left")
                ())
  
  (keybind-desc "v" "X" "X"
                (list "split -v" "focus right" "other" "focus left")
                (list ""))
  
  (defun take-lispcode (x)
    (cadr x))
  
  (defun comitem-stringify-form (comitem)
    (cond ((atom comitem) (resolve-string comitem))
          ;; This is required for really minor case. If we want to use
  
negative.code: (keybind t "^c" raw screen ((focus up)) ())
  (keybind t "^p" window-select window-select
           ((prev))
           ((echo (make-dqstring "[window-select] (prev)"))))
  ;;; Both of following two commands outputs [s] as an echo message:
  ;;;     1. eval "echo"\40"[s]"
  ;;;     2. eval "echo"\40"\"[s]\""
  ;;; In 1., [s] is the argument for echo command. The argument for echo command
  ;;; in 2. is "[s]".
  ;;;     alt-1. echo [s]
  ;;;     alt-2. echo "[s]"
  
  ;;; The :LISP form allows follwing thing. This example is not preferrable, though.
  (let ((x "'focus down'")
        (y "-v"))
    (keybind nil "j" window-select window-select
             ((:lisp x) (focus up) (split (:lisp y)))
             ()))
  
  (define-symbol-macro escape (format t "~&escape ~a~%" (resolve-string (read))))
  
  (defparameter *hardstatus-string* "")
  
  ;;; Dec. 3rd 2012, chiku
  ;;; In order to output one ^ in the hardstatus line, a man should provide
  ;;; "\"\\^\\^\"" to screen-keybind, and screen-keybind will convert it into
  ;;; "\"\\\"\\\\\\^\\\\\\^\\\"\"". That user is responsible for providing the
  ;;; first one. This DEFAULT-MESSAGE function has same responsibility. This is
  ;;; the reason for why I write the escape process in this function and why
  ;;; I do not write such escape process for MESSAGE function.
  (defun default-message (dst primary-command-desc)
    (make-dqstring
      (concat-str "%{= }%?%E[" (resolve-string dst) "]"
                  (if (not (zerop (length primary-command-desc)))
                    (concat-str " ("
                                (escape #\^ primary-command-desc #\^)
                                ")")
                    "")
                  "%:[raw]%?" *hardstatus-string*)))
  
  (defun message (msg &optional (hardstatus-format *hardstatus-string*))
    (make-dqstring
      (concat-str msg hardstatus-format)))
  
  (defun set-hardstatus-string (str)
    (progn (setf *hardstatus-string* str)
           (format t "~&hardstatus string ~a~%"
                   (default-message 'screen ""))))
  
  (define-symbol-macro hardstatus-string
                       (set-hardstatus-string (read)))
  
  (set-hardstatus-string "%030=%{B.} %{-}%-w%{=b Mw}%{+u}%{+s}%n %t%{-}%{-}%{-}%+w%{B.} %{-}%=%m/%d %02c")
  
  (defmacro keybind-common (strm key start dst (&rest commands) &optional message)
    " message : any form that is evaluated into a string.
  