anchor.diff:  (define-insn-2 emit-shl "shl")
   (define-insn-2 emit-sar "sar")
   
  -(defun emit-movzx (out src dest src-scale &rest dest-scale)
  +(define (emit-movzx out src dest src-scale . dest-scale)
     (setq dest-scale (if (null dest-scale) value-scale (car dest-scale)))
     (labels ((movzx (src-scale dest-scale)
                (emit out "mov~A ~A,~A"
  
positive.code: 
  ;;; Use RBX as the allocation pointer, since there are no relevant
  ;;; instructions that clobber it implicitly.
  (defvar %alloc %b)
  
  ;;; (first general-registers) is used to hold results and caller arity
  ;;; (second general-registers) is used to pass the arg frame to a function.
  (defvar general-registers (list %a %c %d %si %di))
  (defvar general-register-count (length general-registers))
  
  (defvar %func %bp)
  (defvar %nargs %di)
  (defvar %funcres %a)
  
  ;;; Address modes
  
  (defun immediate (x)
    (lambda (scale) (format nil "$~A" x)))
  
  (defun dispmem (correction offset reg &rest reg2)
    (lambda (scale)
      (if (null reg2)
          (format nil "~A(~A)" (- offset correction) (usual-register reg))
          (format nil "~A(~A,~A)" (- offset correction) (usual-register reg)
                  (usual-register (first reg2))))))
  
  (defun mem (reg)
    (lambda (scale) (format nil "(~A)" (usual-register reg))))
  
  ;;; Condition codes
  
negative.code: (define-insn-1 emit-neg "neg")
  (define-insn-1 emit-idiv "idiv")
  
  (defmarco (define-insn-0 name insn)
    `(define (,name out . scale)
       (emit out "~A~A" ,insn
             (elt insn-size-suffix (if scale (car scale) value-scale)))))
  
  