anchor.diff:  	(setf (gethash sym (car *envts*)) val))
   
   (defun get-variable (sym envts)
  +	(print "get-variable")
   	(if (equal nil envts)
   		(values nil nil)
  -		(progn 
  -			(multiple-value-setq (var flag) (gethash sym (car envts)))
  +		(progn
  +			(if (listp envts)
  +				(multiple-value-setq (var flag) (gethash sym (car envts)))
  +				(multiple-value-setq (var flag) (gethash sym envts)))
   			(if (eql t flag)
   				(values var t)
   				(get-variable sym (cdr envts))))))
  
positive.code: 			(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
  				(cond ((equal 'if (car expr)) (if-eval expr))
  							((equal 'set! (car expr)) (set-eval expr))
  							((equal 'quote (car expr)) (quote-eval expr))
  
negative.code: 			(progn
  				(mapcar #'set-variable formal-args args)
  				(let ((result (mapcar #'evall body-exprs)))
  					;(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
  ;;; A copy of *envts* at the time the closure was defined
  (defun make-closure (formal body )
  	(list 'closure formal body))
  
  ;;; 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
  