anchor.diff: -;;Setting up stuff with all the registers and shit
  -(defparameter *number-registers* 12)
  -
   ;;contains name of the register, consed with a number if subscript goes from 0 - n-1
   (defparameter *mnemonics*
     '((zero)
  
positive.code: ;;Can be rewritten using find
  
  (defun find-empty-t-register ()
    (dolist (reg *register-list*)
      (when (and (equal (register-type reg) '$t)
  	       (register-free? reg))
        (return reg))))
  
  (defun temp-register-allot (constant)
    (let ((a  (find-empty-t-register)))
      (with-output-to-string (stream *output*)
        (format stream "li ~a , ~a ~%" a constant))
      (setf (register-value a) constant
  	  (register-temp? a) t
  	  (register-free? a) nil)
      a))
  
  (defun free-temp-register (params)
    "Takes a list of registers and frees those who are temporary"
    (dolist (param params)
      (when (and param (register-temp? param))
        (setf (register-free? param) t))))
  
  (defparameter *global-environment* '())
  
  (defun make-frame (var-val-list)
    "var-val list is ((var value) (var value)). Value defaults to 0"
    (let ((frame (make-hash-table )))
      (dolist (var-val var-val-list)
        (if (listp var-val)
  	  (setf (gethash (car var-val) frame) (cdr var-val) )
  	  (setf (gethash var-val frame) 0)))))
  
  
  (defparameter *procedures* (make-hash-table))
  
  (defmacro defprocedure (func &body body)
  `(setf (gethash ,func *procedures*) (lambda (params)
  				  (let ((output ( find-empty-t-register)))
  				    (with-output-to-string (s *output*)
  				      ,@body)
  				    (free-temp-register params)
  				    output)))
    )
  
  (defprocedure '+
  
negative.code: ;;List storing all the registers
  (defvar *register-list* '())
  
  ;;Creates a list with all the registers
  (dolist  (part *mnemonics*)
    (if (cdr part)
        (dotimes (x (cdr part))
  