anchor.diff:                                                         (gensym))
                                                :definition-point *current-lambda*))
                               keys))
  -         (aok (make-instance 'lexical-variable
  -                             :inherit form
  -                             :name (gensym "ALLOW-OTHER-KEYS")
  -                             :definition-point *current-lambda*))
  -         (itr (make-instance 'lexical-variable
  -                             :inherit form
  -                             :name (gensym)
  -                             :definition-point *current-lambda*))
  -         (current-keyword (make-instance 'lexical-variable
  -                                         :inherit form
  -                                         :name (gensym)
  -                                         :definition-point *current-lambda*)))
  -    (labels ((create-key-test-list (key-args values suppliedp)
  -               (cond (key-args
  -                      `(if (call eql ,current-keyword (quote ,(caar (first key-args))))
  -                           (if ,(first suppliedp)
  -                               (quote nil)
  -                               (progn
  -                                 (setq ,(first suppliedp) 't)
  -                                 (setq ,(first values) (call cadr ,itr))))
  -                           ,(create-key-test-list (rest key-args) (rest values) (rest suppliedp))))
  -                     (allow-other-keys
  -                      '(quote nil))
  -                     (t
  -                      `(if ,aok
  -                           (quote nil)
  -                           (if (call eql ,current-keyword (quote :allow-other-keys))
  -                               (quote nil)
  -                               (call error
  -                                     'sys.int::simple-program-error
  -                                     ':format-control '"Unknown &KEY argument ~S. Expected one of ~S."
  -                                     ':format-arguments (call list ,current-keyword (quote ,(mapcar 'caar keys)))))))))
  -             (bind-variable (name value)
  +         (rest (if (lexical-variable-p original-rest)
  +                   original-rest
  +                   (make-instance 'lexical-variable
  +                                  :inherit form
  +                                  :name (gensym "REST")
  +                                  :definition-point *current-lambda*))))
  +    (labels ((bind-variable (name value)
                  (list name
                        (wrap-type-check name (ast value form))))
                (create-key-let-body (key-args values suppliedp)
  
positive.code:                      (t body))))
        (ast `(let (,@(mapcar (lambda (x) (list x '(quote nil))) values)
                    ,@(mapcar (lambda (x) (list x '(quote nil))) suppliedp)
                      (,aok (quote ,(if allow-other-keys t nil)))
                      (,itr ,(etypecase rest
                               (special-variable
                                `(call symbol-value (quote ,rest)))
                               (lexical-variable
                                rest))))
                (progn
                  ,@(when (not allow-other-keys)
                      `((tagbody aok-tb
                           (aok-entry
                            (go aok-test aok-tb))
                           (aok-head
                            (progn
                              (if (call eql (call car ,itr) (quote :allow-other-keys))
                                  (progn
                                    (setq ,aok (call car (call cdr ,itr)))
                                    (go aok-out aok-tb))
                                  (quote nil))
                              (setq ,itr (call cddr ,itr))
                              (go aok-test aok-tb)))
                           (aok-test
                            (if ,itr
                                (go aok-head aok-tb)
                                (go aok-out aok-tb)))
                           (aok-out
                            (quote nil)))
                        (setq ,itr ,(etypecase rest
                                      (special-variable
                                       `(call symbol-value (quote ,rest)))
                                      (lexical-variable
                                       rest)))))
                  (tagbody tb
                     (entry
                      (go test-tag tb))
                     (head-tag
                      (progn
                        (if (call null (call cdr ,itr))
                            (call error
                                  'sys.int::simple-program-error
                                  ':format-control '"Odd number of &KEY arguments.")
                            (quote nil))
                        (let ((,current-keyword (call car ,itr)))
                          ,(create-key-test-list keys values suppliedp))
                        (setq ,itr (call cddr ,itr))
                        (go test-tag tb)))
                     (test-tag
                      (if ,itr
                          (go head-tag tb)
                          (quote nil))))
                  ,(create-key-let-body keys values suppliedp)))
             form))))
  
  
negative.code: (defmethod lower-keyword-arguments-1 ((form lambda-information))
    (let ((*current-lambda* form))
      (when (lambda-information-enable-keys form)
        ;; TODO: If &REST or &COUNT are special, they should be lowered to
        ;; lexicals and those lexicals used for the &KEY processing.
        (unless (lambda-information-count-arg form)
          ;; Add in a &COUNT arg.
          (setf (lambda-information-count-arg form)
                (make-instance 'lexical-variable
                               :inherit form
                               :name (gensym "COUNT")
                               :definition-point *current-lambda*
                               :ignore :maybe)))
        (unless (lambda-information-rest-arg form)
          ;; Add in a &REST arg and make it dynamic-extent.
          (setf (lambda-information-rest-arg form)
  