anchor.diff:  
   ;;; Expands the pattern into the template
   (defun macro-expand (expr)
  +	(setf *symbols* ())
  +	(setf *exprs* ())
   	(let* ((macro (gethash (car expr) *macro-table*))
  -				(syntax-rules (get-syntax macro))
  -				(body (syntax-set (cdr expr) (cdr syntax-rules) (get-template macro)))) ;; going to be a list of some kind need to match expressions to variables in the list
  -		(if (flat-p body)
  -			(evall 'body)
  +				(syntax-rules (get-syntax macro)))
  +		(tree-matching syntax-rules expr)
  +		(let ((body (syntax-set *exprs* *symbols* (get-template macro)))) ;; going to be a list of some kind need to match expressions to variables in the list
  +			(print body)
  +			;;;(evall body))))
   			(car (last (mapcar #'evall body))))))
   
  -(defun flat-p (body)
  -	(if (equal nil body)
  -		t
  -		(if (consp (car body))
  -			nil
  -			(flat-p (cdr body)))))
  +;(defun flat-p (body)
  +;	(if (equal nil body)
  +;		t
  +;		(if (consp (car body))
  +;			nil
  +;			(flat-p (cdr body)))))
   
   ;;; Inserts the expressions in place of the arguments in the template of the macro
   (defun syntax-set (exprs args body)
  
positive.code: 
  (defun get-template (macro)
  	(caddr macro))
  		
  ;;; Set up some common macros 
  (define-syntax 'let 
  							 '(let var value-expr body-expr)
  							 '((set! fffn (lambda (var) body-expr)) (fffn value-expr)))
  
  (define-syntax 'or2 '(or2 a b) '(if a a b))
  
  
  
  
negative.code: 
  ;;; Macro System
  ;;; ========================
  ;;; TODO need to implement multiple arguments e.g. '...' in Scheme
  
  ;;; Hash table for storing all the macro patterns
  (defvar *macro-table* (make-hash-table :test #'equal))
  
  ;TODO move these to local scope
  (defvar *symbols* ())
  (defvar *exprs* ())
  
  ;;; Tests if a given expr is a macro by checking to see if the (car expr) is in the table
  (defun macro-p (expr)
  