anchor.diff:    (setf (gethash type *types*) definition)
     type)
   
  -(defun normalize-literals-and-types (x &key force layout (expand-structs t))
  +(defun normalize-literals-and-types (x &key force layout (expand-structs t)
  +                                         keep-literals
  +                                         the)
  +  (when (and (numberp x)
  +             keep-literals)
  +    (return-from normalize-literals-and-types x))
     (typecase x
       ((or (eql :bool)
            (cons (eql :bool)))
  
positive.code:        (use-type (gethash bt *base-types*))))
      (unsigned-byte
       (use-type '(:uint 32))
       (use-type `(:literal (:uint 32) ,x)))
      (signed-byte
       (use-type '(:int 32))
       (use-type `(:literal (:int 32) ,x)))
      (real
       (use-type '(:float 32))
       (use-type `(:literal (:float 32) ,x)))
      ((cons (eql the))
       (let* ((nt (normalize-literals-and-types (second x) :force t))
              (.nv (mapcar 'normalize-literals-and-types (cddr x)))
              (nv (if (typep nt 'scalar)
                      (first .nv)
                      .nv)))
         (use-type nt)
         (if (every (lambda (x) (typep x 'literal)) .nv)
             (use-type (composite-literal nt nv))
             (use-type `(the ,nt ,nv)))))
  
negative.code:     (error "explicit type/constant ops not handled correctly yet..."))
    ;; handle literals in default case since it applies to most
    ;; instructions, and just have a list of ops to skip
    (let ((a (loop for i in args
                   collect (normalize-literals-and-types
                            i
                            :keep-literals (member op *no-auto-constants-ops*)))))
      (unless (equal a (cdr *current-form*))
        (setf *current-form* (cons op a)))))
  
  (defmacro defpass1 (op lambda-list &body body)
    (let ((args (gensym "ARGS")))
  