anchor.diff:  							   Toks31= lists:takewhile(fun(T)-> token_loc(T) =< EndLoc end, Toks3),
   							   NewLen = length(Toks31),
   							   case NewLen >=MinLength of 
  -							       true ->  NewRange = trim_range(tl(Range), {Len1, Len2}),
  -									{StartLn, StartCol} = StartLoc,
  -									{EndLn, EndCol} = EndLoc,
  -									[{[{{File1, StartLn, StartCol}, {File1, EndLn, EndCol}}|NewRange], NewLen, F}];
  -							       false -> []
  +							       true ->  
  +								   NewRange = trim_range(tl(Range), {Len1, Len2}),
  +								   {StartLn, StartCol} = StartLoc,
  +								   {EndLn, EndCol} = EndLoc,
  +								   [{[{{File1, StartLn, StartCol}, {File1, EndLn, EndCol}}|NewRange], NewLen, F}];
  +							       false -> 
  +								   []
   							   end
   						   end,
   					      lists:append(lists:map(Fun2, Units));
  
positive.code:     end.
  	    				
  
  pos_to_syntax_units(Tree, Toks, {Start,{EndLine, EndCol}}) ->    
      %% The next expression is only a quick fix;
      %% EndCol currently refers to the start loc of a token, 
      %% but to be correct, it should be the end loc of the token.
      ExprOrFuns = pos_to_expr_or_fun(Tree, {Start, {EndLine, EndCol+5}}),
      Res = group_syntax_units(Toks, ExprOrFuns),
      lists:filter(fun(E) -> E =/=[] end, Res).
  
  pos_to_expr_or_fun(Tree, {Start, End}) ->
      GetSubExprs = fun() ->
  		     Ts = refac_syntax:subtrees(Tree),
  		     R0 = [[pos_to_expr_or_fun(T, {Start, End}) || T <- G]
  			   || G <- Ts],
  		     lists:flatten(R0)
  		  end,
      {S, E} = refac_util:get_range(Tree),
      if (S >= Start) and (E =< End) ->
  	   case is_expr_or_fun(Tree) of
  	     true -> [Tree];
  	     _ -> GetSubExprs()
  	   end;
         (S > End) or (E < Start) -> [];
         (S < Start) or (E > End) -> GetSubExprs();
         true -> []
      end.
  
  
  is_expr(Node) ->
      As = refac_syntax:get_ann(Node),
      case lists:keysearch(category,1, As) of 
  	{value, {category, C}} ->case C of
  				     expression -> true;
  				     guard_expression -> true;
  				     match_expression -> true;
  				     macro -> true;
  				     _  -> false
  				 end;
  	_ -> false
      end.
  is_expr_or_fun(Node) ->
      case refac_syntax:type(Node) of 
  	function -> true;
  	_ -> is_expr(Node) 
      end.
  
  get_expr_or_fun_seq(_Toks, []) -> [];
  get_expr_or_fun_seq(_Toks, [E]) -> [refac_util:get_range(E)];
  get_expr_or_fun_seq(Toks, [E1, E2 | Es]) ->
      case is_expr(E1) of
        true ->
  	  {EndLoc, StartLoc, Toks2} = get_expr_toks(E1, E2, Toks),
  	  case lists:any(fun (T) -> token_val(T) =/= ',' end, Toks2) or not is_expr(E2) of
  	    true -> [{StartLoc, EndLoc}];
  	    _ -> [{StartLoc, EndLoc}] ++ get_expr_or_fun_seq(Toks, [E2 | Es])
  	  end;
        false ->
  	  case refac_syntax:type(E1) of
  	    function ->
  		{EndLoc, StartLoc, Toks2} = get_expr_toks(E1, E2, Toks),
  		case lists:any(fun (T) -> token_val(T) =/= '.' end, Toks2) or not (refac_syntax:type(E2) == function) of
  		  true -> [{StartLoc, EndLoc}];
  		  _ -> [{StartLoc, EndLoc}] ++ get_expr_or_fun_seq(Toks, [E2 | Es])
  		end;
  	    _ -> get_expr_or_fun_seq(Toks, [E2 | Es])
  	  end
      end.
  
  get_expr_toks(E1, E2, Toks) ->
      {StartLoc, EndLoc} = refac_util:get_range(E1),
      {StartLoc1, _EndLoc} = refac_util:get_range(E2),
      Toks1 = lists:dropwhile(fun (T) -> token_loc(T) =< EndLoc end, Toks),
      Toks2 = lists:takewhile(fun (T) -> token_loc(T) < StartLoc1 end, Toks1),
      {EndLoc, StartLoc, Toks2}.
    
  			 
  group_syntax_units(Toks, Es) ->
      Seq = get_expr_or_fun_seq(Toks, Es), 
      Es1 = lists:nthtail(length(Seq), Es),
      case  Es1 of 
  	[] ->
  	     [Seq];
  	_  -> [Seq|group_syntax_units(Toks, Es1)]
     end.
  
      
  %% =====================================================================
  %% get the alphabet on which the suffix tree is going to be built.
  alphabet() ->
  
negative.code:     {Cs5, FileNames} = duplicated_code_detection(DirFileList, MinClones1, MinLength1),
      ?debug("Filtering out sub-clones.\n", []),
      Cs6 = remove_sub_clones(Cs5),
      ?debug("current time:~p\n", [time()]),
      case length(FileNames) of
           1 -> display_clones(Cs6);
  