anchor.diff:    (let ((hash (make-hash-table :test #'eq)))
       (loop for i from 0 to 31 collecting (setf (gethash (intern (format nil "~S~d" prefix i)) hash) i)) hash))
   
  +(defparameter *mips-instructions* (make-hash-table :test #'eq))
   (defparameter *ee-registers* (make-ee-registers-hash R))
   (defparameter *fpu-registers* (make-ee-registers-hash F))
   (defparameter *register-type-lut* '(rs *ee-registers* rt *ee-registers* rd *ee-registers*
                                       fs *fpu-registers* ft *fpu-registers* fd *fpu-registers*))
   
  -(defun print-hash-entry (key value)
  -    (format t "The value associated with the key ~S is ~S~%" key value))
  -
   ;;; write value to the stream
   
   (defun write-value (stream value byte-count)
  
positive.code: (def-inst-type fpu-type2 ((fd fs))) 
  (def-inst-type fpu-type3 ((rt fs))) 
  
  ;;; List over all ee - instructions
  
  (defparameter *instruction-vector* (make-array 300))
  (defparameter *current-instruction* 0)
  
  (defun make-ee-instructions (enc opcode-list) 
    (loop for i in opcode-list do 
      (setf (gethash (first i) *mips-instructions*) (list (second i) enc))
      (setf (aref *instruction-vector* *current-instruction*) (first i))
      (incf *current-instruction*)))
  
  ;;; instruction encoding
  
  (defparameter *mips-instructions* (make-hash-table :test #'eq))
  
  ;;
  ;; Registers all instructions 
  ;;
  
  (make-ee-instructions (make-encoding :inst 26 :rs 16 :rt 21 :imm 0 :type 0 :func #'inst-type0)
                        '((addi #b001000) (addiu #b001001) (andi #b001100) (daddi #b011000) (daddiu #b011001)
                          (ori   #b001101) (slti #b001010) (sltiu #b001011) (xori   #b001110)
                          (lb  #b100000) (lbu #b100100) (ld  #b110111) (ldl #b011010) (ldr #b011011)
                          (lwl #b100010) (lh  #b100001) (lhu #b100101) (lw  #b100011) (lq  #b011110)
                          (lwl #b100010) (lwr #b100110) (lwu #b100111) (sb  #b101000) (sd  #b111111) 
        (sdl #b101100) (sdr #b101101) (sh  #b101001) (sw  #b101011) (swl #b101010) 
        (swr #b101110) (sq  #b011111)))
  
  (make-ee-instructions (make-encoding :inst 26 :rs 21 :rt 16 :imm 0 :type 0 :func #'inst-type0)
                        '((beq  #b000100) (beql #b000100) (bne  #b000101) (bnel #b010101)))
  
negative.code:       (error (format nil "Invalid instruction name ~{~a~^, ~}" instruction)))
      (funcall (encoding-func (second instruction-info)) stream (first instruction-info) instruction (second instruction-info))))
  
  (defun make-ee-instructions (enc opcode-list) 
    (loop for i in opcode-list do 
      (setf (gethash (first i) *mips-instructions*) (list (second i) enc))))
  
  ;; builds the diffrent instruction types based on the inst-layout data
  
  (defmacro def-inst-type (name inst-layout)
   `(progn
  