anchor.diff:  	 new_variable_name/1, new_variable_name/2,
   	 new_variable_names/2, new_variable_names/3,
   	 strip_comments/1, to_comment/1, to_comment/2,
  -	 to_comment/3, variables/1, vann_clause/4, var_annotate_clause/4]).
  +	 to_comment/3, variables/1, var_annotate_clause/4]).
   
   %% =====================================================================
   %% @spec map(Function, Tree::syntaxTree()) -> syntaxTree()
  
positive.code: %% @see ordsets
  
  annotate_bindings(Tree, Env) ->
      start_env_process(),
      {Tree1, _, _} = vann(Tree, Env, [],[]), 
      stop_env_process(),
      Tree1.
  
  annotate_bindings(Tree, Env, MDefs) ->
      start_env_process(),
      {Tree1, _, _} = vann(Tree, Env, MDefs,[]),
      stop_env_process(),
      Tree1.
      
  
  var_annotate_clause(C, Env, Ms, VI) ->
      start_env_process(),
      {C1, _, _} = vann_clause(C, Env, Ms, VI),
      stop_env_process(),
      C1.
  
  %% =====================================================================
  
negative.code: 		      {ok, Form} = refac_parse:parse_form(Toks2),
  		      [Form1] = refac_syntax:form_list_elements(
  				  refac_recomment:recomment_forms([Form], [])),
  		      {Form2, _, _} = vann_function_1(Form1, Env, Ms, [], Pid),
  		      get_var_info(Form2)
  		end
  	end,
      {Tree2, Bound, Free} = try
  			     F()
  			   of
  			     VI -> vann_function_1(Tree1, Env, Ms, VI, Pid)
  			   catch
  			     _E1:_E2_ -> vann_function_1(Tree1, Env, Ms, [], Pid)
  			   end,
      {update_var_define_locations(Tree2), Bound, Free}.
      
  
  vann_function_1(Tree, Env, Ms, VI, Pid) ->
      Cs = refac_syntax:function_clauses(Tree),
      {Cs1, {_, Free}} = vann_clauses(Cs, Env, Ms, VI, Pid),
      N = refac_syntax:function_name(Tree),
      {N1, _, _} = vann(N, Env, Ms, VI, Pid),
      Tree1 = rewrite(Tree, refac_syntax:function(N1, Cs1)),
      Bound = [],
      {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
  
  vann_rule(Tree, Env, Ms, VI, Pid) ->
      Cs = refac_syntax:rule_clauses(Tree),
      {Cs1, {_, Free}} = vann_clauses(Cs, Env, Ms, VI, Pid),
      N = refac_syntax:rule_name(Tree),
      {N1, _, _} = vann(N, Env, Ms, VI, Pid),
      Tree1 = rewrite(Tree, refac_syntax:rule(N1, Cs1)),
      Bound = [],
      {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
  
  vann_fun_expr(Tree, Env, Ms, VI, Pid) ->
      Cs = refac_syntax:fun_expr_clauses(Tree),
      {Cs1, {_, Free}} = vann_fun_expr_clauses(Cs, Env, Ms, VI, Pid),
      Tree1 = rewrite(Tree, refac_syntax:fun_expr(Cs1)),
      Bound = [],
      {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
  
  vann_match_expr(Tree, Env, Ms, VI, Pid) ->
      E = refac_syntax:match_expr_body(Tree),
      {E1, Bound1, Free1} = vann(E, Env, Ms, VI, Pid),
      Env1 = ordsets:union(Env, Bound1),
      P = refac_syntax:match_expr_pattern(Tree),
      {P1, Bound2, Free2} = vann_pattern(P, Env1, Ms, VI, Pid),
      Bound = ordsets:union(Bound1, Bound2),
      Free = ordsets:union(Free1, Free2),
      Tree1 = rewrite(Tree, refac_syntax:match_expr(P1, E1)),
      Tree2 =ann_bindings(Tree1, Env, Bound, Free), 
      Tree3=constant_propagate(Tree2, Pid),
      {Tree3, Bound, Free}.
  
  vann_case_expr(Tree, Env, Ms, VI, Pid) ->
      E = refac_syntax:case_expr_argument(Tree),
      {E1, Bound1, Free1} = vann(E, Env, Ms, VI, Pid),
      Env1 = ordsets:union(Env, Bound1),
      Cs = refac_syntax:case_expr_clauses(Tree),
      {Cs1, {Bound2, Free2}} = vann_clauses(Cs, Env1, Ms, VI, Pid),
      Bound = ordsets:union(Bound1, Bound2),
      Free = ordsets:union(Free1, Free2),
      Tree1 = rewrite(Tree, refac_syntax:case_expr(E1, Cs1)),
      {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
  
  vann_if_expr(Tree, Env, Ms, VI, Pid) ->
      Cs = refac_syntax:if_expr_clauses(Tree),
      {Cs1, {Bound, Free}} = vann_clauses(Cs, Env, Ms, VI, Pid),
      Tree1 = rewrite(Tree, refac_syntax:if_expr(Cs1)),
      {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
  
  vann_cond_expr(Tree, Env, _Ms, _VI, _Pid) ->
      {ann_bindings(Tree, Env, [], []), [],[]}.   %% TODO: NEED TO CHANGE THIS BACK.
      %% erlang:error({not_implemented, cond_expr}).
  
  vann_try_expr(Tree, Env, Ms, VI, Pid) ->  
      Body = refac_syntax:try_expr_body(Tree),
      {Body1, {Bound1, Free1}} = vann_body(Body, Env, Ms, VI, Pid),
      Cs = refac_syntax:try_expr_clauses(Tree),
      {Cs1, {Bound2, Free2}} = case Cs of 
  				 [] -> {Cs, {[], []}};
  				 _ -> vann_clauses(Cs, Env, Ms, VI, Pid)
  			     end,
      Handlers = refac_syntax:try_expr_handlers(Tree),
      {Handlers1, {Bound3, Free3}} = case Handlers of 
  				       [] -> {Handlers, {[],[]}};
  				       _  ->vann_clauses(Handlers,Env, Ms, VI, Pid)
  				   end,
      After = refac_syntax:try_expr_after(Tree),
      {After1, {Bound4, Free4}} = case After of 
  				    [] -> {After, {[],[]}};
  				    _  -> vann_body(After, Env, Ms, VI, Pid)
  				end,
      Tree1 = rewrite(Tree, refac_syntax:try_expr(Body1, Cs1, Handlers1, After1)),
      Bound = ordsets:union(ordsets:union(ordsets:union(Bound1, Bound2), Bound3),Bound4),
      Free  = ordsets:union(ordsets:union(ordsets:union(Free1, Free2), Free3),Free4),
      {ann_bindings(Tree1, Env, Bound, Free), Bound,Free}.    
  
  vann_receive_expr(Tree, Env, Ms, VI, Pid) ->
      %% 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, Ms, VI, Pid),
  	    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, Ms, VI, Pid),
  	    Es1 = refac_syntax:clause_body(C1),
  	    {T1, _, Free2} = case
  		       refac_syntax:receive_expr_timeout(Tree)
  			 of
  		       none -> {none, [], []};
  		       T -> vann(T, Env, Ms, VI, Pid)
  		     end,
  	    Free = ordsets:union(Free1, Free2),
  	    Tree1 = rewrite(Tree,
  