anchor.diff:  			(if (eql t fl)
   				(if (not (consp sym))
   					sym ;; what the expr evaluates to
  -					(lambda-run sym (mapcar #'evall (cdr expr)))) ; evaluates a user defined closure
  +					(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))
  
positive.code: 	(setf (gethash sym (car *envts*)) val))
  
  (defun get-variable (sym envts)
  	(if (equal nil envts)
  		(values nil nil)
  		(progn 
  			(multiple-value-setq (var flag) (gethash sym (car envts)))
  			(if (eql t flag)
  				(values var t)
  				(get-variable sym (cdr envts))))))
  
negative.code: 
  ;;; 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)
  	(print (cadr expr))
  	(print (cddr 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)
  	(print "lambda-run")
  	(setq TEMP (copy-tree *envts*)) ;;; needs to be a deep copy
  	(setf *envts* (get-envt sym *envts*))
  	(print *envts*)
  	(push (make-envt) *envts*) ;;; make a local environment
  	(let ((formal-args (get-formal closure)) 
  				(body-exprs (get-body closure)))
  