anchor.diff:  
   get_current_state_type_1(TypeInfo, ModName, _ModInfo, eqc_fsm) ->
       StateFuns = get_eqc_fsm_state_functions(ModName, TypeInfo),
  +    ?debug("StateFuns:\n~p\n", [StateFuns]),
       Pars = callbacks(ModName, StateFuns, eqc_fsm),
       get_current_state_type_2(TypeInfo, StateFuns, Pars);
   
   get_current_state_type_1(TypeInfo, ModName, ModInfo, gen_fsm) ->
       StateFuns = get_gen_fsm_state_functions(ModName, ModInfo, TypeInfo),
       Pars = callbacks(ModName, StateFuns, gen_fsm),
  -    ?debug("Pars:\n~p\n", [Pars]),
       Fun = fun ({{M, F, A}, RetType, ArgTypes}) ->
   		  case lists:keysearch({M, F, A}, 1, Pars) of
   		    {value, {{M, F, A}, {Is, ReturnState}}} ->
  
positive.code: 
  
  mk_record_field(Name, Val) ->
      refac_syntax:record_field(refac_syntax:copy_pos(Val, refac_syntax:atom(Name)),
  			      refac_syntax:remove_comments(Val)).
  
  mk_record_fields(RecordFields, Es) ->
      [mk_record_field(Name, Val)|| {Name, Val} <- lists:zip(RecordFields, Es),
  				  refac_syntax:type(Val) =/= underscore].
  
  mk_record_expr(RecordName, Fields) ->
      refac_syntax:record_expr(refac_syntax:atom(RecordName), Fields).
  
  mk_record_expr(T, RecordName,Fields) ->
      refac_syntax:record_expr(T, refac_syntax:atom(RecordName),Fields).
  
  
  mk_record_attribute(RecordName, RecordFields) ->
  
negative.code: 		       throw(E2)
  	       end,
      ?debug("TypeInfo:\n~p\n", [TypeInfo]),
      TypeInfo1 =[{F, Type, RecDict} || {F, Type, RecDict} <-TypeInfo, F == File],
      {Type, RecDict} = case TypeInfo1 of
  			  [] ->
  			      throw({error, ?Msg});
  			  [{File, T, Rec}] ->
  			      {T, Rec}
  		      end,
      {Ts, StateFuns} =get_current_state_type_1(Type, ModName, ModInfo, SM),
      ?debug("RecDict:\n~p\n", [RecDict]),
      ?debug("Current Type:\n~p\n", [Ts]),
      Ts1 = lists:usort([case Tag of 
  			   tuple ->
  			       case Qual of
  				   {Arity, {c, atom, [AtomTag], _}} ->
  				       case lookup_record(AtomTag, Arity - 1, RecDict) of
  					   error -> {Tag, length(Es)};
  					   {ok, _Fields} -> record
  				       end;
  				   _ -> {Tag, length(Es)}
  			       end;
  			   tuple_set ->{tuple, length(Es)};
  			   _ -> Tag
  		       end 
  		       ||{c,Tag, Es, Qual} <-lists:usort(Ts) --[any],
  			is_list(Es)]),
      case Ts1 of
  	[record] ->
  