anchor.diff:  (defparameter *system-licenses*
     '(("cl-ppcre"       . "BSD-2")
       ("split-sequence" . :unknown)
  -    ("terminfo"       . "MIT")))
  +    ("terminfo"       . "MIT")
  +    ("closer-mop"     . "MIT")))
   
   (defun asdf-system-name (system)
     (slot-value system 'asdf::name))
   
   (defun asdf-system-license (system-name)
     (let ((system  (asdf:find-system system-name)))
  -    (if (slot-boundp system 'asdf::licence)
  -        (slot-value system 'asdf::licence)
  -        (or (cdr (assoc system-name *system-licenses* :test 'string-equal))
  -            :unknown))))
  +    (or (cdr (assoc system-name *system-licenses* :test 'string-equal))
  +        (and (slot-boundp system 'asdf::licence)
  +             (slot-value system 'asdf::licence))
  +        :unknown)))
   
   (defun system-depends-on (system)
     (delete (string-downcase system)
  
positive.code:                  :for line = (read-line file nil nil)
                   :while line :do (write-line line out)))))
        (ignore-errors (delete-file path)))))
  
  
  (defun distribution ()
  
negative.code: 
  
  
  (defun lisp-version ()
    (let ((v (lisp-implementation-version)))
      (when (prefixp "Version " v)
        (setf v (subseq v (length "Version "))))
      (with-output-to-string (out)
        (with-input-from-string (inp v)
          (loop
            :with state = :normal
            :for ch = (read-char inp nil nil)
            :while ch
            :do (if (char= ch #\space)
                    (when (eq state :normal)
                      (setf state :space)
                      (write-char #\_ out))
                    (progn
                      (setf state :normal)
                      (case ch
                        ((#\( #\))) ; deleted characters
                        ((#\-) ; substituted characters
                         (write-char #\_ out))
                        (otherwise ; plain characters
                         (write-char ch out))))))))))
  
  ;; (list (lisp-implementation-version) (lisp-version))
  
  (defun executable-name (base)
    (format nil "~(~A-~A-~A-~{~A-~A-~A~}-~A~)"
            base
            (or (lisp-implementation-type-keyword) "unknown")
            (lisp-version)
            (distribution)
            (or (machine-type-keyword) "unknown")))
  
  
  (defun executable-filename (base)
    (format nil "~A~A" (executable-name base)
            #+(or windows win32) ".exe"
            #-(or windows win32) ""))
  
  
  (defun date ()
  