anchor.diff:                                  :destination :rcx))
              (emit (make-instance 'x86-fake-three-operand-instruction
                                   :opcode 'lap:shl64
  -                                :result shift-result
  +                                :result result
                                   :lhs integer
  -                                :rhs :rcx))
  -           (emit (make-instance 'ir:jump-instruction
  -                                :target done
  -                                :values (list shift-result)))
  -           (emit done)))))
  +                                :rhs :rcx))))))
   
   ;;; SINGLE-FLOAT operations.
   
  
positive.code:                                 :values (list temp3)))
             (emit done)))))
  
  (define-builtin mezzano.compiler::%fast-fixnum-left-shift ((integer count) result :has-wrapper nil)
    (cond ((constant-value-p count '(integer 0))
           (let ((count-value (fetch-constant-value count)))
             (cond ((>= count-value (- 64 sys.int::+n-fixnum-bits+))
  
negative.code:                                        :lhs integer
                                         :rhs count-value))))))
          (t
           ;; No need to test for overlong shift counts here. The result must fit
           ;; in a fixnum, so obviously the count is within range or the input
           ;; is 0.
           (let ((count-value (make-instance 'ir:virtual-register :kind :integer)))
             (emit (make-instance 'ir:unbox-fixnum-instruction
                                  :source count
                                  :destination count-value))
  