anchor.diff:  				  refac_syntax:macro_arguments(Tree)
   				    of
   				  none -> {none, {[], []}};
  -				  As1 -> vann_patterns(As1, Env)
  +				  As1 -> vann_patterns(As1, Env, Ms, VI)
   				end,
   	  N = refac_syntax:macro_name(Tree),
   	  Tree1 = rewrite(Tree, refac_syntax:macro(N, As)),
   	  {ann_bindings(Tree1, Env, Bound, Free), Bound, Free};
         _Type ->
  -	  F = vann_patterns_join(Env),
  -	  {Tree1, {Bound, Free}} = mapfold_subtrees(F, {[], []},
  -						    Tree),
  +	  F = vann_patterns_join(Env, Ms, VI),
  +	    {Tree1, {Bound, Free}} = mapfold_subtrees(F, {[], []},Tree),
   	  {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}
       end.
   
  -vann_patterns_join(Env) ->
  +vann_patterns_join(Env, Ms, VI) ->
       fun (T, {Bound, Free}) ->
  -	    {T1, Bound1, Free1} = vann_pattern(T, Env),
  +	    {T1, Bound1, Free1} = vann_pattern(T, Env, Ms, VI),
   	    {T1,
   	     {ordsets:union(Bound, Bound1),
   	      ordsets:union(Free, Free1)}}
       end.
   
  -vann_fun_expr_patterns_join(Env) ->
  +vann_fun_expr_patterns_join(Env, Ms, VI) ->
       fun (T, {Bound, Free}) ->
  -	    {T1, Bound1, Free1} = vann_fun_expr_pattern(T, Env),
  +	    {T1, Bound1, Free1} = vann_fun_expr_pattern(T, Env, Ms, VI),
   	    {T1,
   	     {ordsets:union(Bound, Bound1),
   	      ordsets:union(Free, Free1)}}
       end.
   
  -vann_patterns(Ps, Env) ->
  -    lists:mapfoldl(vann_patterns_join(Env), {[], []}, Ps).
  -
  -vann_fun_expr_patterns(Ps, Env) ->
  -    lists:mapfoldl(vann_fun_expr_patterns_join(Env),
  +vann_patterns(Ps, Env, Ms, VI) ->
  +    lists:mapfoldl(vann_patterns_join(Env, Ms, VI), {[], []}, Ps).
  +
  +vann_fun_expr_patterns(Ps, Env, Ms, VI) ->
  +    lists:mapfoldl(vann_fun_expr_patterns_join(Env, Ms, VI),
   		   {[], []}, Ps).
   
  -vann_define(D, Env) -> 
  +vann_define(D, Env, Ms, VI) -> 
       Name = refac_syntax:attribute_name(D),
       Args = refac_syntax:attribute_arguments(D),    
       MacroHead = hd(Args),
  
positive.code:     {ann_bindings(Tree1, Env, Bound, Free), Bound,Free}.    %% TODO: NEED TO CHANGE THIS BACK.
      %% erlang:error({not_implemented, try_expr}).
  
  vann_receive_expr(Tree, Env) ->
      %% The timeout action is treated as an extra clause.
      %% Bindings in the expiry expression are local only.
      Cs = refac_syntax:receive_expr_clauses(Tree),
      Es = refac_syntax:receive_expr_action(Tree),
      case Es of 
  	[] ->
  	    {Cs1,{Bound, Free}} = vann_clauses(Cs, Env),
  	    Tree1 = rewrite(Tree, refac_syntax:receive_expr(Cs1, none, [])),
  	    {ann_bindings(Tree1, Env, Bound, Free), Bound, Free};
  	_ ->
  	    C = refac_syntax:clause([], Es),
  	    {[C1 | Cs1], {Bound, Free1}} = vann_clauses([C | Cs],
  							Env),
  	    Es1 = refac_syntax:clause_body(C1),
  	    {T1, _, Free2} = case
  		       refac_syntax:receive_expr_timeout(Tree)
  			 of
  		       none -> {none, [], []};
  		       T -> vann(T, Env)
  		     end,
  	    Free = ordsets:union(Free1, Free2),
  	    Tree1 = rewrite(Tree,
  
negative.code: 
  push(N, C, Cs) when N > 0 -> push(N - 1, C, [C | Cs]);
  push(0, _, Cs) -> Cs.
  
  
  remove_whites(Toks) ->
      F = fun(T) ->
  		case T of
  		    {whitespace, _, _} -> [];
  		    {comment, _, _} -> [];
  		    {qatom, L, V} ->[{atom, L, V}];
  		    _ -> [T]
  		end
  	end,
      lists:flatmap(F, Toks).
  
  get_var_info(Tree) ->
      F = fun(T, S) ->
  		case refac_syntax:type(T) of
  		    variable ->
  			V = refac_syntax:variable_name(T),
  			P = refac_syntax:get_pos(T),
  			As = refac_syntax:get_ann(T),
  			ordsets:add_element({{V, P}, As}, S);		    
  		    _ -> S
  		end
  	end,
      fold(F, [], Tree).
  	   
  