anchor.diff:    (+ low (ash high 8)))
   
   (defun wrap-overflow (value is-word)
  +  "Wrap around an overflowed value."
     (if is-word (mod value #x10000) (mod value #x100)))
   
   ;;; Instruction loader
   
  -(defun load-instructions (instrs)
  +(defun load-instructions-into-ram (instrs)
     (setf (register :ip) 0)
  -  (setf (subseq *ram* 0 #x7fff) instrs))
  +  (setf (subseq *ram* 0 #x7fff) instrs)
  +  (length instrs))
   
   (defun next-instruction ()
     (incf (register :ip))
  
positive.code:     ((= opcode #xf8) (clear-carry-flag))
      ((= opcode #xf9) (set-carry-flag))))
  
  (defun loop-instructions (&optional (return-disasm nil))
    "Loop through loaded instructions."
    (setf *disasm* return-disasm)
    (loop
       for ret = (parse-opcode (next-instruction))
       collecting ret into disasm
       until (equal ret '("hlt"))
       finally (return (if return-disasm disasm t))))
  
  (defparameter *test-instructions* #(#x40 #x40 #x40 #x91 #xb0 #xff #x50 #x5a #x52 #x51 #x48 #xbe #x02 #x03 #xf4))
  
negative.code:   (reverse-little-endian (elt segment loc) (elt segment (1+ loc))))
  
  (defun write-word-to-ram (loc word &optional (segment *ram*))
    "Write a word to a RAM segment."
    (setf (elt segment loc) (logand word #x00ff))
    (setf (elt segment (1+ loc)) (ash (logand word #xff00) -8)))
  
  