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),
  +	  F = vann_patterns_join(Env, Ms, VI),
   	  {Tree1, {Bound, Free}} = mapfold_subtrees(F, {[], []},
   						    Tree),
   	  {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}
       end.
   
  -vann_fun_expr_pattern(Tree, Env) ->
  +vann_fun_expr_pattern(Tree, Env,Ms, VI) ->
       case refac_syntax:type(Tree) of
         variable ->
  -	  V = refac_syntax:variable_name(Tree),
  -	  Pos = refac_syntax:get_pos(Tree),
  -	  case lists:keysearch(V, 1, Env) of
  -	    {value, {V, _}} ->
  -		%% shandowing
  -		Bound = [{V, Pos}],
  -		Free = [],
  -		Def = [Pos],
  -		{ann_bindings(Tree, Env, Bound, Free, Def), Bound, Free};
  -	    false ->
  -		%% binding occurrence
  -		Bound = [{V, Pos}],
  -		Free = [],
  -		Def = [Pos],
  -		{ann_bindings(Tree, Env, Bound, Free, Def), Bound, Free}
  -	  end;
  -      match_expr ->
  +	    V = refac_syntax:variable_name(Tree),
  +	    P = refac_syntax:get_pos(Tree),
  +	    case VI of 
  +		[] -> Bound = [{V, P}],
  +		      Free = [],
  +		      Def = [P],
  +		      {ann_bindings(Tree, Env, Bound, Free, Def), Bound, Free};		
  +		_ ->
  +		    case lists:keysearch({V, P}, 1, VI) of
  +			{value, {{V, P}, As}} ->
  +			    {value, {bound, Bound1}} = lists:keysearch(bound, 1,As),
  +			    {value, {free, Free1}} = lists:keysearch(free, 1,As),
  +			    {value, {def, Def1}} = lists:keysearch(def, 1,As),
  +			    {value, {env, Env1}} = lists:keysearch(env, 1,As),
  +			    {ann_bindings(Tree, Env1, Bound1, Free1, Def1), Bound1, Free1};
  +			false -> 
  +			    throw("Wrangler AST annotation error!")
  +		    end
  +	    end;
  +	match_expr ->
   	  %% Alias pattern
   	  P = refac_syntax:match_expr_pattern(Tree),
  -	  {P1, Bound1, Free1} = vann_pattern(P, Env),
  +	  {P1, Bound1, Free1} = vann_pattern(P, Env, Ms, VI),
   	  E = refac_syntax:match_expr_body(Tree),
  -	  {E1, Bound2, Free2} = vann_pattern(E, Env),
  +	  {E1, Bound2, Free2} = vann_pattern(E, Env, Ms, VI),
   	  Bound = ordsets:union(Bound1, Bound2),
   	  Free = ordsets:union(Free1, Free2),
   	  Tree1 = rewrite(Tree, refac_syntax:match_expr(P1, E1)),
  
positive.code: 		   false -> Node
  		 end
  	  end;
        Gs ->
  	  if Depth > 1 ->
  		 Gs1 = [[limit_1(T, Depth - 1, Node)
  			 || T <- limit_list(G, Depth, Node)]
  
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).
  	   
  