anchor.diff:              ,commands
               (,(cond ((null message)
                        `(hardstatus string
  -                                  (:lisp (sstringarg (default-message
  -                                                       ',dst
  -                                                       ,(com-stringify-form (car commands)))))))
  +                                  (:lisp (default-message
  +                                           ',dst
  +                                           (spacing-join
  +                                             ,@(mapcar #'comitem-stringify-form
  +                                                       (car commands)))))))
                       ((zerop (length message)) ())
  -                    (t `(hardstatus string (:lisp (sstringarg ,message))))))))
  +                    (t `(hardstatus string (:lisp (message ,message))))))))
   
   (keybind-common t "j" snormal snormal ((focus down)))
   (keybind-common t "k" screen raw ((focus up)) "focus up")
  
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:         ((stringp strsrc) strsrc)
          (t (error "Malformed string source: ~s" strsrc))))
  
  (defun spacing-join (&rest strs)
    (format nil "~{~a~^ ~}" strs))
  
  (defun join/40 (&rest args)
    (format nil "~{~a~^\\40~}" args))
  
  (join/40 "split" "-v")
  (princ
    (apply #'spacing-join
           (mapcar (papply (apply #'join/40))
                   '(("split" "-v")
                     ("focus" "right")
                     ("other")
                     ("focus" "left")))))
  
  (defun dqstringify (str)
    (concat-str "\"" str "\""))
  
  (defmacro gen-escape-fn (prepend-char &rest chars)
    (with-gensyms (c)
      `(lambda (,c)
         (if (inq ,c ,@chars)
           (list ,prepend-char ,c)
           (list ,c)))))
  
  (defmacro escape (prepend-char str &rest chars)
    `(coerce (mapcan (gen-escape-fn ,prepend-char ,@chars)
                     (coerce ,str 'cons))
             'string))
  
  (macroexpand-1 '(gen-escape-fn #\\ #\" #\# #\^))
  
  (defun make-dqstring (str)
    " Returns a string whose content is recognized identical to ``str'';{{{
      in the meaning of screen's double quoted string.
      Please be aware that ``str'' is a lisp object, string.
       Actually speaking, this function is a little strange. I mean,
      it should not exists. For example, if ^ is required to escaped
      by prepending a \, then it should be  done by the input side. Even
      if this function exists or not, the input side have to care about very
      similar point: which character should be escaped? If this function
      didn't exists, the input side must know which character must be
      escaped, and construct proper screen-dq-string. This function is
      only for reducing this annoying part. Thus, I have to do following
      2 things:
          1. DO NOT scented the existance of this function!
          2. Advertise NOTHING must be escaped. Just write the
             screen string contents, and wrap it by double quotes!
             The double quotes are for making it to Lisp string,
             not screen string.
    ";}}}
    (dqstringify
      (escape #\\ str #\" #\# #\^ #\\)))
  
  (join/40 "split" "-v")
  (princ
    (apply #'spacing-join
           (mapcar (papply (apply #'join/40))
                   (maptree #'make-dqstring
                   '(("split" "-v")
                     ("focus" "right")
                     ("other")
                     ("focus" "left"))))))
  
  (defun make-evalarg (&rest command-components)
    (apply #'join/40 (mapcar #'make-dqstring command-components)))
  
  (defun state-leave-desc (state)
    (case state
  