anchor.diff:  ;;; Instructions
   
   (defconstant insn-size-suffix '("b" "w" "l" "q"))
  -(defvar usual-size-suffix (elt insn-size-suffix value-scale))
  -
  -(defmacro define-insn-2 (name insn)
  -  `(defun ,name (out src dest &rest scale)
  +(define usual-size-suffix (elt insn-size-suffix value-scale))
  +
  +(defmarco (define-insn-2 name insn)
  +  `(define (,name out src dest . scale)
        (emit-insn-2 out ,insn src dest (and scale (car scale)))))
   
  -(defun emit-insn-2 (out insn src dest scale)
  +(define (emit-insn-2 out insn src dest scale)
     (unless scale
       (setq scale value-scale))
     (emit out "~A~A ~A, ~A" insn (elt insn-size-suffix scale)
  
positive.code:             (movzx src-scale 2))
          (movzx src-scale dest-scale))))
  
  (defun emit-clear (out reg)
    (emit-xor out reg reg 2))
  
  (define (emit-push out reg)
  
negative.code: 
  ;;; Use RBX as the allocation pointer, since there are no relevant
  ;;; instructions that clobber it implicitly.
  (define %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.
  (define general-registers (list %a %c %d %si %di))
  (define general-register-count (length general-registers))
  
  (define %func %bp)
  (define %nargs %di)
  (define %funcres %a)
  
  ;;; Address modes
  
  (define (immediate x)
    (lambda (scale) (format nil "$~A" x)))
  
  (define (dispmem correction offset reg . 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))))))
  
  (define (mem reg)
    (lambda (scale) (format nil "(~A)" (usual-register reg))))
  
  ;;; Condition codes
  