anchor.diff:  
   (defun match (token symbol)
     (string= token symbol))
  +
  +(defun match-adv (tokenizer symbol)
  +  (match (advanze-token tokenizer) symbol))
   
   (defun parse-csharp (tokenizer)
     (let ((ast-tree (list(make-ast-node :file "name"))))
  
positive.code: Imports = Using & Using
  Import = 'using' String stmtEnd 
  stmtEnd = ';' 
  
  Class = ClassDeclaration ( ClassParameters ) : ClassBody
  ClassDeclaration = 'partial'? 'public'? class String
  ClassParameters = VariableDeclaration | VariableDeclaration , ClassParameters
  VaribleDeclaration = Type String
  Type = int | string | bool
  
  
negative.code: 	nil)))
  
  (defun parse-class (tokenizer ast-tree)
    (parse-class-declaration tokenizer ast-tree))
    ;;(parse-class-body tokenizer ast-tree ()))
      
  (defun block-start (tokenizer) 
      (match-adv tokenizer "{"))
  
  (defun block-end (tokenizer) 
      (match-adv tokenizer "}"))
  
  (defun parse-class-declaration (tokenizer ast-tree)
    (let* ((class-declaration-node (make-ast-node :class-declaration ()))
  	 (class-modifiers-node (make-ast-node :class-visibility (grab-tokens-until tokenizer "class")))
  	 (class-name-node (make-ast-node :class-name (advanze-token tokenizer))))
        (push-node class-modifiers-node class-declaration-node)
        (push-node class-name-node class-declaration-node)
        (push-node class-declaration-node ast-tree)
        ;;(advanze-token tokenizer)
        (when (not (block-start tokenizer))
  	(progn
  	  (advanze-token tokenizer)
  	  (let ((class-inheritance-node (make-ast-node 
  					 :class-inheritances 
  					 (grab-tokens-until-filtered tokenizer
  								     "{"
  								     ","))))
  	    (push-node class-inheritance-node class-declaration-node)))
  	ast-tree)))
  
  (defun parse-class-param-list (tokenizer)
    (let* ((param-list (grab-tokens-until tokenizer ")"))
  	 (ast-node (make-ast-node :class-parameters (delete "," param-list :test #'string=))))
      ast-node))
  
  (defun grab-tokens-until-filtered (tokenizer end-string seperator)
    (delete seperator 
  	  (grab-tokens-until tokenizer end-string)
  	  :test
  	  #'string=))
  
  (defun grab-tokens-until (tokenizer end-string)
    (grab-tokens-until-fn tokenizer (lambda (x) (string= (current-token x) end-string))))
  