anchor.diff:  		C2 = refac_util:update_ann(refac_util:update_ann(C1, {bound, Bound}), {free, Free}),
   		[C2];
   	    _ -> %% Expr does not use any of the vars declared in Patterns.
  -		%%io:format("NewBody:\n~p\n", [NewBody]),
   		{Bound, Free} = lists:foldl(fun (E, {Bd, Fr}) ->
   						    {Bd1, Fr1} = {refac_util:get_bound_vars(E), refac_util:get_free_vars(E)},
   						    {ordsets:union(Bd, Bd1), ordsets:union(Fr, ordsets:subtract(Fr1, Bd))}
  
positive.code:     FunClauses = refac_syntax:function_clauses(FunDef),
      NewFunClauses = lists:map(fun(Cs) ->
  			    process_a_clause(AnnAST, ModName,Cs, Expr) end, FunClauses),
      NewFunDef = refac_syntax:function(FunName, NewFunClauses),
      sliced_funs ! {add, {{ModName, FunName1, Arity}, NewFunDef}},
      case returns_undefined(NewFunDef) of 
  	true ->    %% None of the variables depending on the selected expression is exported.
  	    get_all_sliced_funs();
  	false -> CallerFuns = get_caller_funs(Files, {ModName, FunName1, Arity}),
  		 F = fun(T,Acc) -> case refac_syntax:type(T) of 
  				       application ->
  					   Op = refac_syntax:application_operator(T),
  					   Ann = refac_syntax:get_ann(Op),
  					   case lists:keysearch(fun_def,1, Ann) of
  					       {value, {fun_def, {ModName, FunName1, Arity, _, _}}} ->
  						   [T|Acc];
  					       _ ->  Acc
  					   end;
  				       _ -> Acc
  				   end
  		     end,	 
  		 case CallerFuns of 
  		     [] -> get_all_sliced_funs();
  		     _ ->  SliceCriterion = lists:flatmap(fun(FunDef1) -> AppExprs = refac_syntax_lib:fold(F, [], FunDef1),
  								     lists:map(fun(E) -> {FunDef1, E} end, AppExprs)
  						      end, CallerFuns),
  			   lists:flatmap(fun(SC) ->forward_slice_1(Files, AnnAST, ModName,SC) end, SliceCriterion)
  		 end		 
      end.
  
  returns_undefined(FunDef) ->
  
negative.code: sliced_funs(State) ->
      receive
  	{From, get, Key} ->
  	    Res = case lists:keysearch(Key, 1, State) of
  		      {value, {Key, Value}} ->
  			   {sliced_funs, value, Value};
  		      false -> {sliced_funs, false}
  		  end,
  	    From ! Res,
  	    sliced_funs(State);
  	{add, {Key, Value}} ->
  	    case lists:keysearch(Key, 1, State) of 
  		    {value, {Key, _}} ->  %% This should not happen.
  			State1 =lists:keyreplace(Key,1, State, {Key, Value}), 
  			sliced_funs(State1);
  		    false -> sliced_funs([{Key, Value}|State])
  		end;
  	 {From, get_all} ->
  	    From ! {sliced_funs, State},
  	    sliced_funs(State);
  	 stop ->
  