anchor.diff:  (defun make-envt ()
   	(make-hash-table :test #'equal))
   
  +;;; Returns the formal arguments of a given closure (lambda expression)
   (defun get-formal (closure)
   	(car (cdr closure)))
   
  +;;; Returns the body of a closure (lambda expression)
   (defun get-body (closure)
   	(car (cdr (cdr  closure))))
   
  +;;; Returns true if the expr is a closure, nil otherwise
   (defun closure-p (expr)
   	(if (equal 'closure (car expr))
   		t
  
positive.code: (defun get-function (op)
  	(gethash op *func-table*))
  
  ;;; TODO add &rest to handle arbitrary number of arguments
  (defun scheme-and (expr1 expr2)
  	(if (and (eql t expr1) (eql t expr2))
  		t 
  
negative.code: ;;; (+ 3 4 9)
  ;;; --> 16
  ;;; TODO maybe change the whole structure to a cond?
  ;(defun evall (expr)
  ;	(if (atomp expr)
  ;		expr
  ;		(progn
  ;			(if (consp expr) ;; change which one is running depending on if a function call or variable
  ;				(multiple-value-setq (sym fl) (get-variable (car expr) *envts*)) ;; to handle (f 3) for example 
  ;				(multiple-value-setq (sym fl) (get-variable expr *envts*)))
  ;			(if (eql t fl)
  ;				(if (not (consp sym))
  ;					sym ;; what the expr evaluates to
  ;					(lambda-run (car expr) sym (mapcar #'evall (cdr expr)))) ; evaluates a user defined closure
  ;				(cond ((equal 'if (car expr)) (if-eval expr))
  ;							((equal 'set! (car expr)) (set-eval expr))
  ;							((equal 'quote (car expr)) (quote-eval expr))
  ;							((equal 'lambda (car expr)) (lambda-eval expr))
  ;							(t 
  ;								(multiple-value-setq (op flag) (get-function (car expr)))
  ;								(if (eql flag t)
  ;									(apply op (mapcar #'evall (rest expr))))))))))
  
  (defun evall (expr)
  	(cond ((atomp expr) expr) ;; if it's an atom should evaluate to itself
  				((not (consp expr)) (multiple-value-setq (sym fl) (get-variable expr *envts*))
  														(if (eql t fl)
  															sym)) ;; should be variable that maps to a value x -> 3 for example
  				((consp expr) (multiple-value-setq (sym fl) (get-variable (car expr) *envts*)) ;;; expr is an s-expression so could be any of the s-expression forms
  											(cond
  												((eql fl t)(lambda-run (car expr) sym (mapcar #'evall (cdr expr)))) ;; if expr is a cons like (f 2) and f is in the environment, than f must be a function call 
  												((equal 'if (car expr)) (if-eval expr)) ;; start of special forms checking
  												((equal 'set! (car expr)) (set-eval expr))
  												((equal 'quote (car expr)) (quote-eval expr))
  												((equal 'lambda (car expr)) (lambda-eval expr))
  												(t ;; must be a built in function 
  													(multiple-value-setq (op flag) (get-function (car expr)))
  													(if (eql flag t)
  														(apply op (mapcar #'evall (rest expr)))))))))
  
  ;;; Creates a closure object given a lambda expression
  ;;; Doesn't run the function because it has no actual arguments only defines the function to be called later
  ;;; A copy of *envts* at the time the function was called
  (defun lambda-eval (expr)
  	(make-closure (cadr expr) (cddr expr)))
  
  ;;; Runs a closure object as a function by matching formal parameters with actual parameters
  (defun lambda-run (sym closure args)
  	(setq TEMP (copy-tree *envts*)) ;;; needs to be a deep copy
  	(setf *envts* (get-envt sym *envts*))
  	(push (make-envt) *envts*) ;;; make a local environment
  	(let ((formal-args (get-formal closure)) 
  				(body-exprs (get-body closure)))
  