anchor.diff:  			(progn
   				(mapcar #'set-variable formal-args args)
   				(let ((result (mapcar #'evall body-exprs)))
  -					(print *envts*)
  +					;(print *envts*)
  +					(setf *envts* TEMP) ;;; restore regular scope
   					(pop *envts*)
   					(nth (- (length result) 1) result))))))
   
   ;;; Creates a new closure with the envts being a deep copy of the list of current environments do a copy tree or something
   ;;; needs to be a deep copy for lexical scope preservation
  -(defun make-closure (formal body)
  +;;; A copy of *envts* at the time the closure was defined
  +(defun make-closure (formal body )
   	(list 'closure formal body))
   
  -(defun get-envt (closure)
  -	(car (cdr closure)))
  +;;; Restores *envts* to the state it was in when the function was defined
  +(defun get-envt (sym envts)
  +	(print "get-evnts")
  +	(print envts)
  +	(if (not (listp envts))
  +		envts ;; top-level
  +		(progn
  +			(multiple-value-setq (op flag) (gethash sym (car envts)))
  +			(if (equal t flag)
  +				envts
  +				(progn 
  +					(pop envts)
  +					(get-envt sym envts))))))
   
   ;;; Makes an environment for when the lambda function is running
   ;;; All parameters matched to formal arguments will be placed in this environment
  
positive.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
  (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 (closure args)
  	(print "lambda-run")
  	(push (make-envt) *envts*) ;;; make a local environment
  	(let ((formal-args (get-formal closure)) 
  				(body-exprs (get-body closure)))
  
negative.code: 			(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))
  