anchor.diff:  
   
   get_caller_funs(Files, {ModName, FunName, Arity}) ->
  -    CallGraph = refac_util:build_call_graph(Files, []),
  +    CallGraph = refac_util:build_callgraph(Files, []),
       lists:flatmap(fun ({{_Caller, CallerDef}, Callee}) -> 
   			  case lists:member({ModName, FunName, Arity}, Callee) of
   			      true -> [CallerDef];
  
positive.code:     Body = refac_syntax:clause_body(hd(refac_syntax:function_clauses(NewFun1))),
      Body1 = rm_unused_exprs(Body),  %%Qn: how about the guard expression?
      NewFun2 = refac_syntax:function(FunName, [refac_syntax:clause(Patterns, none, Body1)]),
      %%io:format("Fun after slicing:\n"),
      %%io:format(refac_prettypr:format(NewFun2)),				    
      %% Body1.
      NewFun2.
      
  
  
negative.code: 					    {[], []}, Body),
      case FreeVarsInBody of 
  	[] ->
  	    [refac_syntax:block_expr(Body)];
  	_ -> 
  	    SlicePoints = collect_app_sites(AnnAST, ModName, FunName, Arity),
  	    case SlicePoints of 
  		[] -> [refac_syntax:block_expr(Body)]; %% could not find any use sites of this function.
  		_ -> Slices = lists:map(fun({Fun, S}) ->
  						lists:flatmap(fun(E) -> backward_slice(Files, AnnAST, ModName, Fun, E) end, S)
  					end,  SlicePoints),
  		     FunExpr = refac_syntax:fun_expr([C]),
  		     Result = lists:map(fun(S) ->refac_syntax:application(FunExpr, S) end, Slices),
  		     Result       
  	    end
      end. 
  		 
  	    
  collect_app_sites(AnnAST, ModName, FunName, Arity) ->    
      HandleSpecialFuns=fun(Args) ->
  			      Args1 = list_to_tuple(lists:reverse(Args)),
  			      A = element(1, Args1),
  			      F = element(2, Args1),
  			      M = element(3, Args1),
  			      case {refac_syntax:type(M), refac_syntax:type(F), refac_syntax:type(A)} of 
  				  {atom, atom, list} ->
  				      case {refac_syntax:atom_value(M), refac_syntax:atom_value(F), refac_syntax:list_length(A)} of 
  					  {ModName, FunName, Arity} -> [refac_syntax:list_elements(A)];
  					  _ -> []
  				      end;
  				  _ -> []
  			      end
  		      end,
       F1 = fun(T,Acc) ->
  		case refac_syntax:type(T) of 
  		    application ->
  			Op = refac_syntax:application_operator(T),
  			Args = refac_syntax:application_arguments(T),
  			Ann = refac_syntax:get_ann(Op),
  			case lists:keysearch(fun_def,1, Ann) of
  			    {value, {fun_def, {M, F, A, _, _}}} ->
  				case {M, F, A} of 
  				    {ModName, FunName, Arity} ->
  					case Args of 
  					    [] -> Acc;
  					    _ -> Acc ++ [Args]  
  					end;
  				    {erlang, apply, 3} -> HandleSpecialFuns(Args)++Acc;
  				    {erlang, spawn, 3} -> HandleSpecialFuns(Args)++Acc;
  				    {erlang, spawn, 4} -> HandleSpecialFuns(Args)++Acc;
  				    {erlang, spawn_link, 3} -> HandleSpecialFuns(Args)++Acc;
  				    {erlang, spawn_link, 4} -> HandleSpecialFuns(Args)++Acc;
  				    _ -> Acc
  				end;
  			    _ -> Acc			
  			end;
  		    _ -> Acc
  		end
  	 end,				
      F = fun(T, Acc) ->
  		case refac_syntax:type(T) of 
  		    function ->
  