anchor.diff:  	true ->
   	    remove_sub_clone_pairs(CPs,Acc);
   	_ -> remove_sub_clone_pairs(CPs, [CP|Acc])
  -    end.
  +    end. 
   	
   %% derive clone classes from clone pairs.	
   get_clone_classes(ClonePairs,Thresholds, Tabs) ->
  
positive.code: %%                                                                  %%
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  attach_fun_call_to_range(_C = {Ranges, {Len,Freq}, AU}, Tabs) ->
      RangesWithFunCalls=[{Range, generate_fun_call_1(Range, AU, Tabs)} 
  			|| Range <- Ranges],
      {RangesWithFunCalls, {Len, Freq}, 
       simplify_anti_unifier(AU)}.
  
  generate_fun_call_1(Range, AUForm, Tabs) ->
      Exprs=get_expr_list(Range, Tabs#tabs.tmp_ast_tab),
      AUFunClause=hd(refac_syntax:function_clauses(AUForm)),
      Pats = refac_syntax:clause_patterns(AUFunClause),
      AUBody = refac_syntax:clause_body(AUFunClause),
      %% it would be a bug if this does not match. 
      {true, Subst} = 
  	case length(AUBody) - length(Exprs) of 
  	    1 ->
  		SubAUBody = lists:sublist(AUBody, 1, length(AUBody) - 1),
  		Res=unification:expr_unification(SubAUBody, Exprs),
  		case Res of 
  		    false -> 
  			?wrangler_io("\n not same length\n",[]),
  			?wrangler_io(" Case1:\n",[]),
  			?wrangler_io("\nAUBody:\n",[]),
  			?wrangler_io("~s", [refac_prettypr:format(refac_syntax:block_expr(AUBody))]),
  			?wrangler_io("\nExprs:\n",[]),		   
  			?wrangler_io("~s", [refac_prettypr:format(refac_syntax:block_expr(Exprs))]),
  			Res;
  		    _ -> Res
  		end;
  	    0 ->
  		Res=unification:expr_unification(AUBody, Exprs),
  		case Res of
  		    false ->
  			?wrangler_io("\nsame length\n",[]),
  			?wrangler_io("\nAUBody:\n",[]),
  			?wrangler_io("~s", [refac_prettypr:format(refac_syntax:block_expr(AUBody))]),
  			?wrangler_io("\nExprs:\n",[]),		   
  			?wrangler_io("~s", [refac_prettypr:format(refac_syntax:block_expr(Exprs))]),
  			Res;
  		    _ -> Res
  		end
  	end,
      %% Need to check side-effect here. but it is a bit slow!!!
      FunCall=make_fun_call(new_fun, Pats, Subst),
      refac_prettypr:format(FunCall).
      
  
  make_fun_call( FunName, Pats, Subst) ->
      Fun = fun (P) ->
  		  case refac_syntax:type(P) of
  		      variable ->
  			  PName = refac_syntax:variable_name(P),
  			  case lists:keysearch(PName, 1, Subst) of
  			      {value, {PName, Par}} -> Par;
  			      _ -> refac_syntax:atom(undefined)
  			  end;
  		      underscore ->
  			  refac_syntax:atom(undefined);
  
negative.code: 		atom ->
  		    As = refac_syntax:get_ann(Operator),
  		    {value, {fun_def, {M, _F, _A, _, _}}} = lists:keysearch(fun_def,1,As),
  		    case M== erlang orelse M=='_' of 
  			true ->
  			    {Node, false};
  			false ->
  			    Mod = refac_syntax:atom(M),
  			    Operator1 = refac_misc:rewrite(Operator, refac_syntax:module_qualifier(Mod, Operator)),
  			    Node1 = refac_misc:rewrite(Node, refac_syntax:application(Operator1, Arguments)),
  			    {Node1, false}
  		    end;
  		_ -> 
  		    {Node, false}
  	    end;
  