anchor.diff:      [C1|C2];
   clauses([]) -> [].
   
  -clause({clause,Line,H0,G0,B0},Bound) ->
  +clause({clause,Anno,H0,G0,B0},Bound) ->
       {H1,Bound1} = copy(H0,Bound),
       {B1,_Bound2} = copy(B0,Bound1),
  -    {clause,Line,H1,G0,B1}.
  -
  -copy({call,Line,{remote,_Line2,{atom,_Line3,ets},{atom,_Line4,fun2ms}},
  +    {clause,Anno,H1,G0,B1}.
  +
  +copy({call,Anno,{remote,_Anno2,{atom,_Anno3,ets},{atom,_Anno4,fun2ms}},
         As0},Bound) ->
  -    {transform_call(ets,Line,As0,Bound),Bound};
  -copy({call,Line,{remote,_Line2,{atom,_Line3,dbg},{atom,_Line4,fun2ms}},
  +    {transform_call(ets,Anno,As0,Bound),Bound};
  +copy({call,Anno,{remote,_Anno2,{atom,_Anno3,dbg},{atom,_Anno4,fun2ms}},
         As0},Bound) ->
  -    {transform_call(dbg,Line,As0,Bound),Bound};
  -copy({match,Line,A,B},Bound) ->
  +    {transform_call(dbg,Anno,As0,Bound),Bound};
  +copy({match,Anno,A,B},Bound) ->
       {B1,Bound1} = copy(B,Bound),
       {A1,Bound2} = copy(A,Bound),
  -    {{match,Line,A1,B1},gb_sets:union(Bound1,Bound2)};
  -copy({var,_Line,'_'} = VarDef,Bound) ->
  +    {{match,Anno,A1,B1},gb_sets:union(Bound1,Bound2)};
  +copy({var,_Anno,'_'} = VarDef,Bound) ->
       {VarDef,Bound};
  -copy({var,_Line,Name} = VarDef,Bound) ->
  +copy({var,_Anno,Name} = VarDef,Bound) ->
       Bound1 = gb_sets:add(Name,Bound),
       {VarDef,Bound1};
  -copy({'fun',Line,{clauses,Clauses}},Bound) -> % Dont export bindings from funs
  +copy({'fun',Anno,{clauses,Clauses}},Bound) -> % Dont export bindings from funs
       {NewClauses,_IgnoredBindings} = copy_list(Clauses,Bound),
  -    {{'fun',Line,{clauses,NewClauses}},Bound};
  -copy({named_fun,Line,Name,Clauses},Bound) -> % Dont export bindings from funs
  +    {{'fun',Anno,{clauses,NewClauses}},Bound};
  +copy({named_fun,Anno,Name,Clauses},Bound) -> % Dont export bindings from funs
       Bound1 = case Name of
                    '_' -> Bound;
                    Name -> gb_sets:add(Name,Bound)
                end,
       {NewClauses,_IgnoredBindings} = copy_list(Clauses,Bound1),
  -    {{named_fun,Line,Name,NewClauses},Bound};
  -copy({'case',Line,Of,ClausesList},Bound) -> % Dont export bindings from funs
  +    {{named_fun,Anno,Name,NewClauses},Bound};
  +copy({'case',Anno,Of,ClausesList},Bound) -> % Dont export bindings from funs
       {NewOf,NewBind0} = copy(Of,Bound),
       {NewClausesList,NewBindings} = copy_case_clauses(ClausesList,NewBind0,[]),
  -    {{'case',Line,NewOf,NewClausesList},NewBindings};
  +    {{'case',Anno,NewOf,NewClausesList},NewBindings};
   copy(T,Bound) when is_tuple(T) ->
       {L,Bound1} = copy_list(tuple_to_list(T),Bound),
       {list_to_tuple(L),Bound1};
  
positive.code: 		      fixup_environment(X,B) 
  	      end,
  	      L);
  fixup_environment({var,Line,Name},B) ->
      case lists:keysearch(Name,1,B) of
  	{value,{Name,Value}} -> 
  	    freeze(Line,Value);
  	_ ->
  	    throw({error,Line,{?ERR_UNBOUND_VARIABLE,atom_to_list(Name)}})
      end;
  fixup_environment(T,B) when is_tuple(T) ->
      list_to_tuple(
  
negative.code: copy_case_clauses([],Bound,AddSets) ->
      ReallyAdded = gb_sets:intersection(AddSets),
      {[],gb_sets:union(Bound,ReallyAdded)};
  copy_case_clauses([{clause,Anno,Match,Guard,Clauses}|T],Bound,AddSets) ->
      {NewMatch,MatchBinds} = copy(Match,Bound),
      {NewGuard,GuardBinds} = copy(Guard,MatchBinds), %% Really no new binds
      {NewClauses,AllBinds} = copy(Clauses,GuardBinds),
  