anchor.diff:  
   (defsetf flag-p set-flag-p)
   
  +(defun bit-vector->integer (bit-vector)
  +  "Create a positive integer from a bit-vector."
  +  (reduce #'(lambda (first-bit second-bit)
  +              (+ (* first-bit 2) second-bit))
  +          bit-vector))
  +
  +(defun flags-register (&optional (is-word t))
  +  (let ((flags (vector 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)))
  +    (setf (elt flags (- 15 0)) (flag :cf))
  +    (setf (elt flags (- 15 2)) (flag :pf))
  +    (setf (elt flags (- 15 4)) (flag :af))
  +    (setf (elt flags (- 15 6)) (flag :zf))
  +    (setf (elt flags (- 15 7)) (flag :sf))
  +    (when is-word
  +	(setf (elt flags (- 15 11)) (flag :of)))
  +    (bit-vector->integer flags)))
  +
  +(defun set-flags-register (value &optional (is-word t))
  +  (setf (flag-p :cf) (logbitp 0 value))
  +  (setf (flag-p :pf) (logbitp 2 value))
  +  (setf (flag-p :af) (logbitp 4 value))
  +  (setf (flag-p :zf) (logbitp 6 value))
  +  (setf (flag-p :sf) (logbitp 7 value))
  +  (when is-word
  +      (setf (flag-p :of) (logbitp 11 value)))
  +  value)
  +
  +(defsetf flags-register set-flags-register)
  +
   (defun byte-in-ram (location segment)
     "Read a byte from a RAM segment."
     (elt segment location))
  
positive.code:   `(parse-group-opcode
       (0 (parse-group-byte-pair ,opcode inc-indirect mod-bits r/m-bits))
       (1 (parse-group-byte-pair ,opcode dec-indirect mod-bits r/m-bits))))
  
  ;;; Opcode parsing
  
  
negative.code: 
  (defparameter *ram* (make-array (* 64 1024) :initial-element 0 :element-type '(unsigned-byte 8)) "Primary segment")
  (defparameter *stack* (make-array (* 64 1024) :initial-element 0 :element-type '(unsigned-byte 8)) "Stack segment")
  (defparameter *flags* '(:af 0 :cf 0 :of 0 :pf 0 :sf 0 :zf 0) "Flags")
  (defparameter *registers* '(:ax 0 :bx 0 :cx 0 :dx 0 :bp 0 :sp #x100 :si 0 :di 0) "Registers")
  (defparameter *ip* 0 "Instruction pointer")
  (defparameter *has-carried* nil "Whether the last wraparound changed the value")
  