anchor.diff:  (defmarco (define-insn-2 name insn)
     (quasiquote
       (define ((unquote name) out src dest . scale)
  -      (emit-insn-2 out (unquote insn) src dest (and scale (car scale))))))
  +      (emit-insn-2 out (unquote insn) src dest scale))))
   
   (define (emit-insn-2 out insn src dest scale)
  -  (unless scale
  -    (set! scale value-scale))
  +  (set! scale (if (null? scale) value-scale (car scale)))
     (emit out "~A~A ~A, ~A" insn (insn-size-suffix scale)
           (insn-operand src scale) (insn-operand dest scale)))
   
  -(define-insn-2 emit-mov "mov")
   (define-insn-2 emit-lea "lea")
   (define-insn-2 emit-add "add")
   (define-insn-2 emit-sub "sub")
  
positive.code: ;;; Address modes
  
  (define (immediate x)
    (format nil "$~A" x))
  
  (define (dispmem correction offset reg . reg2)
    (if (null reg2)
  
negative.code:                    (insn-operand dest dest-scale))))
      (if (= dest-scale 3)
          (if (= src-scale 3)
              (emit out "movq ~A, ~A" (insn-operand src 3) (insn-operand dest 3))
              (movzx src-scale 2))
          (movzx src-scale dest-scale))))
  
  (define (emit-clear out reg . scale)
    (set! scale (if (null? scale) value-scale (car scale)))
    (emit-xor out reg reg (min 2 scale)))
  
  (define (emit-mov out src dest . scale)
    (cond ((and (eq? src 0) (register? dest))
           (emit-clear out dest))
          ((and (number? src) (register? dest) (> src 0) (< src 1000000))
           (emit-movzx out src dest
                       (min 2 (if (null? scale) value-scale (car scale)))))
          (true
           (emit-insn-2 out "mov" src dest scale))))
  
  (define (emit-push out reg)
    (emit out "push~A ~A" value-insn-size-suffix (value-sized reg)))
  