anchor.diff:      case NewBody == [refac_syntax:tuple([refac_syntax:atom(error), refac_syntax:atom("Error with evaluation")])] of
         true -> [];
         _ ->
  -	  BoundVars = lists:concat(lists:map(fun (P) -> refac_util:get_bound_vars(P) end, Patterns)),
  +	  BoundVars = lists:flatmap(fun (P) -> refac_util:get_bound_vars(P) end, Patterns),
   	  case FreeVars -- BoundVars =/= FreeVars of
   	    true ->  %% Expr uses some of the vars declared in Patterns.
   		C1 = refac_syntax:clause(Patterns, none, NewBody),
  
positive.code: %% the License for the specific language governing rights and limitations
  %% under the License.
  
  
  %% Author contact: hl@kent.ac.uk, sjt@kent.ac.uk
  %%
  %% =====================================================================
  %%
  %% @doc This module implements both forward and back inter-function slicing algorithms. The 
  %% current implementation does not handle message passing yet. 
  %% @end
  -module(refac_slice).
  
  -export([forward_slice/4, backward_slice/5]). 
  
  -export([sliced_funs/0]).
  
  %% Forward slicing the program with an the Expr in FunDef as the slicing criterion.
  forward_slice(Files, AnnAST, ModName, {FunDef, Expr})  ->
      start_slice_env_process(),
      Res = forward_slice_1(Files, AnnAST, ModName, {FunDef, Expr}),
      stop_slice_env_process(),
  
negative.code: 	    Args = refac_syntax:case_expr_argument(E),
  	    {Bound1, Free1} = {refac_util:get_bound_vars(Args), refac_util:get_free_vars(Args)},
  	    Clauses = refac_syntax:case_expr_clauses(E),
  	    NewClauses = lists:flatmap(fun (C) -> process_a_clause(C, Expr) end, Clauses), %% process each case clause.
  	    {Bound2, Free2} = lists:foldl(fun (C, {Bd, Fr}) ->
  						  {Bd1, Fr1} = {refac_util:get_bound_vars(C), refac_util:get_free_vars(C)},
  						  {ordsets:intersection(Bd, Bd1), ordsets:union(Fr, Fr1)}
  