anchor.diff:              :format-arguments (list name))
         (return-from lift-lambda))
       ;; Attempt to match the argument list with the function's lambda list.
  -    (when (or optional-args rest-arg)
  -      ;; Bail out.
  -      (warn 'sys.int::simple-style-warning
  -	    :format-control "Cannot inline ~S yet."
  -	    :format-arguments (list name))
  -      (return-from lift-lambda))
       (unless (arguments-match-lambda-list lambda arg-list)
         ;; Bail out.
         (warn 'simple-warning
  
positive.code:                                                            :ignore :maybe))
                                    arg-list))
             (key-pairs (nthcdr (length required-args) argument-vars)))
        (labels ((build-key-bindings (keys)
                   (cond (keys
                          (do ((p 0 (+ p 2))
                               (i (nthcdr (length required-args) arg-list) (cddr i)))
                              ((null i)
                               ;; Not provided, use the initform.
                               `(let ((,(cadar (first keys)) ,(second (first keys))))
                                  ,(build-key-bindings (rest keys))))
                            (when (eql (second (car i)) (caar (first keys)))
                              ;; Keywords match, use this argument.
                              (return `(let ((,(cadar (first keys)) ,(nth (1+ p) key-pairs)))
                                         ,(build-key-bindings (rest keys)))))))
                         (t `(progn ,@(mapcar #'ll-form (lambda-information-body lambda)))))))
          ;; Evaluate arguments.
          `(let ,(mapcar #'list argument-vars arg-list)
             ;; Bind required arguments.
             (let ,(mapcar #'list required-args argument-vars)
               ,(build-key-bindings key-args)))))))
  
  (defun ll-function-form (form)
    (ll-implicit-progn (cdr form))
  
negative.code:   (ll-implicit-progn (cdr form))
    form)
  
  ;; Doesn't support fuzzy allow-other-keys matching.
  (defun arguments-match-lambda-list (lambda arg-list)
    (let ((arg-count (length arg-list))
          (req-count (length (lambda-information-required-args lambda)))
          (opt-count (length (lambda-information-optional-args lambda))))
      (cond ((lambda-information-enable-keys lambda)
             (let ((keywords (mapcar 'caar (lambda-information-key-args lambda))))
               (when (and (>= arg-count req-count)
                          (evenp (- arg-count (+ req-count opt-count))))
                 (do ((i (nthcdr (+ req-count opt-count) arg-list) (cddr i)))
                     ((null i)
                      t)
                   (unless (and (listp (car i))
                                (= (length (car i)) 2)
                                (eql (first (car i)) 'quote)
                                (member (second (car i)) keywords))
                     (return nil))))))
            ((lambda-information-rest-arg lambda)
             (<= req-count arg-count))
            (t (<= req-count arg-count (+ req-count opt-count))))))
  
  (defun lift-lambda (lambda arg-list)
    (let ((name (or (lambda-information-name lambda) 'lambda))
  	(required-args (lambda-information-required-args lambda))
  	(optional-args (lambda-information-optional-args lambda))
  	(rest-arg (lambda-information-rest-arg lambda))
  