anchor.diff:      PredefBifs = [{PBif} || PBif <- ?PREDEF_BIFS],
       ets:insert(?NT_INSTR_BIFS, PredefBifs),
       ?NT_INSTR_IGNORED = ets:new(?NT_INSTR_IGNORED, EtsNewOpts),
  -    ets:insert(?NT_INSTR_IGNORED, Ignores),
  +    ets:insert(?NT_INSTR_IGNORED, [{erlang},{ets},{?REP_MOD}] ++ Ignores),
       ?NT_INSTR = ets:new(?NT_INSTR, EtsNewOpts),
       ets:insert(?NT_INSTR, {?FAIL_BB, FailBB}),
       %% Create a temp dir to save renamed code
  
positive.code: -spec delete_and_purge(concuerror:options()) -> 'ok'.
  delete_and_purge(Options) ->
      %% Unload and purge modules.
      ModsToPurge = [new_module_name(IM) || {IM} <- ets:tab2list(?NT_INSTR_MODS)],
      Fun = fun (M) -> code:purge(M), code:delete(M) end,
      lists:foreach(Fun, ModsToPurge),
      %% Delete temp directory (ignore errors).
  
negative.code: 
  %% ---------------------------
  %% Rename a module for the instrumentation.
  %% 1. Don't rename `ignored' modules
  %% 2. Don't rename `BIFS'.
  %% 3. If module is instrumented rename it.
  %% 4. If we are in `fail_uninstrumented' mode rename all modules.
  -spec check_module_name(atom(), atom(), non_neg_integer()) -> atom().
  check_module_name(Module, Function, Arity) ->
      Rename = (not ets:member(?NT_INSTR_IGNORED, Module))
          andalso (not ets:member(?NT_INSTR_BIFS, {Module, Function, Arity}))
          andalso (ets:member(?NT_INSTR_MODS, Module)
              orelse ets:lookup_element(?NT_INSTR, ?FAIL_BB, 2)),
      case Rename of
          true  -> new_module_name(Module);
          false -> Module
      end.
  
  -spec new_module_name(atom() | string()) -> atom().
  new_module_name(StrModule) when is_list(StrModule) ->
      %% Check that module is not already renamed.
      case StrModule of
          (?INSTR_PREFIX ++ _OldModule) ->
              %% No need to rename it
              list_to_atom(StrModule);
          _OldModule ->
              list_to_atom(?INSTR_PREFIX ++ StrModule)
      end;
  new_module_name(Module) ->
      new_module_name(atom_to_list(Module)).
  
  -spec old_module_name(atom()) -> atom().
  old_module_name(NewModule) ->
  