anchor.diff:      (dolist (arg required-args)
         (when (lexical-variable-p arg)
   	(setf (lexical-variable-definition-point arg) *current-lambda*)))
  -    #+nil(dolist (arg optional-args)
  -      (when (lexical-variable-p arg)
  -	(setf (lexical-variable-definition-point arg) *current-lambda*)))
  -    #+nil(when (lexical-variable-p rest-arg)
  +    (dolist (arg optional-args)
  +      (when (lexical-variable-p (first arg))
  +	(setf (lexical-variable-definition-point (first arg)) *current-lambda*))
  +      (when (lexical-variable-p (third arg))
  +	(setf (lexical-variable-definition-point (third arg)) *current-lambda*)))
  +    (when (lexical-variable-p rest-arg)
         (setf (lexical-variable-definition-point rest-arg) *current-lambda*))
       (dolist (arg key-args)
         (when (lexical-variable-p (second (first arg)))
  
positive.code:   (ll-implicit-progn (cdr form))
    form)
  
  ;; NOTE: Only support required and keyword args.
  ;; Doesn't support fuzzy allow-other-keys matching or suppliedp variables.
  (defun arguments-match-lambda-list (lambda arg-list)
    (let ((arg-count (length arg-list))
          (req-count (length (lambda-information-required-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)))
                 (do ((i (nthcdr req-count arg-list) (cddr i)))
                     ((null i)
                      t)
                   (when (third (car i))
                     (return nil))
                   (unless (and (listp (car i))
                                (= (length (car i)) 2)
                                (eql (first (car i)) 'quote)
                                (member (second (car i)) keywords))
                     (return nil))))))
            (t (= arg-count req-count)))))
  
  (defun lift-lambda (lambda arg-list)
    (let ((name (lambda-information-name lambda))
  	(required-args (lambda-information-required-args lambda))
  	(optional-args (lambda-information-optional-args lambda))
  	(rest-arg (lambda-information-rest-arg lambda))
  
negative.code:                                                            :ignore :maybe))
                                    arg-list))
             (key-pairs (nthcdr (length required-args) argument-vars)))
        (labels ((build-required-bindings (req-args arg-vars)
                   (cond (req-args
                          `(let ((,(first req-args) ,(first arg-vars)))
                             ,(build-required-bindings (rest req-args) (rest arg-vars))))
                         (t (build-optional-bindings optional-args arg-vars))))
                 (build-optional-bindings (opt-args arg-vars)
                   (cond ((and opt-args arg-vars)
                          (destructuring-bind (var init-form suppliedp)
                              (first opt-args)
                            (declare (ignore init-form))
                            `(let ,(if suppliedp
                                       `((,var ,(first arg-vars))
                                         (,suppliedp 't))
                                       `((,var ,(first arg-vars))))
                               ,(build-optional-bindings (rest opt-args) (rest arg-vars)))))
                         (opt-args
                          (destructuring-bind (var init-form suppliedp)
                              (first opt-args)
                            `(let ,(if suppliedp
                                       `((,var ,init-form)
                                         (,suppliedp 'nil))
                                       `((,var ,init-form)))
                               ,(build-optional-bindings (rest opt-args) '()))))
                         (t (build-rest-binding arg-vars))))
                 (build-rest-binding (arg-vars)
                   (if rest-arg
                       `(let ((,rest-arg (list ,@arg-vars)))
                          ,(build-key-bindings key-args))
                       (build-key-bindings key-args)))
                 (build-key-bindings (keys)
                   (cond (keys
                          (destructuring-bind ((keyword var) init-form suppliedp)
                              (first keys)
                            (do ((p 0 (+ p 2))
                                 (i (nthcdr (+ (length required-args)
                                               (length optional-args))
                                            arg-list)
                                    (cddr i)))
                                ((null i)
                                 ;; Not provided, use the initform.
                                 `(let ,(if suppliedp
                                            `((,var ,init-form)
                                              (,suppliedp 'nil))
                                            `((,var ,init-form)))
                                    ,(build-key-bindings (rest keys))))
                              (when (eql (second (car i)) keyword)
                                ;; Keywords match, use this argument.
                                (return `(let ,(if suppliedp
                                                   `((,var ,(nth (1+ p) key-pairs))
                                                     (,suppliedp 't))
                                                   `((,var ,(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)
             ,(build-required-bindings required-args argument-vars))))))
  
  (defun ll-function-form (form)
    (ll-implicit-progn (cdr form))
  