anchor.diff:    end.
   
   process_loop(#concuerror_info{notify_when_ready = {Pid, true}} = Info) ->
  -  ?debug_flag(?wait, notifying_parent),
  +  ?debug_flag(?loop, notifying_parent),
     Pid ! ready,
     process_loop(Info#concuerror_info{notify_when_ready = {Pid, false}});
   process_loop(Info) ->
  -  ?debug_flag(?wait, waiting),
  +  ?debug_flag(?loop, process_loop),
     receive
       #event{event_info = EventInfo} = Event ->
  +      ?debug_flag(?loop, got_event),
         Status = Info#concuerror_info.status,
         case Status =:= exited of
           true ->
  +          ?debug_flag(?loop, exited),
             process_loop(notify(exited, Info));
           false ->
             NewInfo = Info#concuerror_info{next_event = Event},
             case EventInfo of
               undefined ->
  -              ?debug_flag(?wait, {waiting, exploring}),
  +              ?debug_flag(?loop, exploring),
                 NewInfo;
               _OtherReplay ->
  -              ?debug_flag(?wait, {waiting, replaying}),
  +              ?debug_flag(?loop, replaying),
                 NewInfo
             end
         end;
       {exit_signal, #message{data = {'EXIT', _From, Reason}} = Message, Notify} ->
  +      ?debug_flag(?loop, {signal, Reason}),
         Trapping = Info#concuerror_info.flags#process_flags.trap_exit,
         case is_active(Info) of
           true ->
             case Reason =:= kill of
               true ->
  -              ?debug_flag(?wait, {waiting, kill_signal}),
  +              ?debug_flag(?loop, kill_signal),
                 catch Notify ! {trapping, Trapping},
                 exiting(killed, [], Info#concuerror_info{caught_signal = true});
               false ->
                 case Trapping of
                   true ->
  -                  ?debug_flag(?trap, {waiting, signal_trapped}),
  +                  ?debug_flag(?loop, signal_trapped),
                     self() ! {message, Message, Notify},
                     process_loop(Info);
                   false ->
                     catch Notify ! {trapping, Trapping},
                     case Reason =:= normal of
                       true ->
  -                      ?debug_flag(?wait, {waiting, normal_signal_ignored}),
  +                      ?debug_flag(?loop, ignore_normal_signal),
                         process_loop(Info);
                       false ->
  -                      ?debug_flag(?wait, {waiting, exiting_signal}),
  +                      ?debug_flag(?loop, error_signal),
                         exiting(Reason, [], Info#concuerror_info{caught_signal = true})
                     end
                 end
             end;
           false ->
  +          ?debug_flag(?loop, ignoring_signal),
             catch Notify ! {trapping, Trapping},
             process_loop(Info)
         end;
       {message, Message, Notify} ->
  -      ?debug_flag(?wait, {waiting, got_message}),
  +      ?debug_flag(?loop, message),
         Trapping = Info#concuerror_info.flags#process_flags.trap_exit,
         catch Notify ! {trapping, Trapping},
         case is_active(Info) of
           true ->
  -          ?debug_flag(?receive_, {message_enqueued, Message}),
  +          ?debug_flag(?loop, enqueueing_message),
             Old = Info#concuerror_info.messages_new,
             NewInfo =
               Info#concuerror_info{
                 messages_new = queue:in(Message, Old)
                },
  +          ?debug_flag(?loop, enqueued_msg),
             case NewInfo#concuerror_info.status =:= waiting of
               true -> NewInfo#concuerror_info{status = running};
               false -> process_loop(NewInfo)
             end;
           false ->
  -          ?debug_flag(?receive_, {message_ignored, Info#concuerror_info.status}),
  +          ?debug_flag(?loop, ignoring_message),
             process_loop(Info)
         end;
       reset ->
  -      ?debug_flag(?wait, {waiting, reset}),
  +      ?debug_flag(?loop, reset),
         NewInfo =
           #concuerror_info{
              ets_tables = EtsTables,
  
positive.code:             end,
            has_matching_or_after(PatternFun, Timeout, Location, NewInfo, Mode);
          false ->
            NewInfo = process_loop(InfoIn),
            {FinalResult, FinalNewOldMessages} =
              has_matching_or_after(PatternFun, Timeout, NewInfo),
  
negative.code:      link_monitor_handlers(fun handle_monitor/3, Monitors)],
    FinalInfo =
      lists:foldl(FunFold, ExitInfo#concuerror_info{exit_reason = Reason}, FunList),
    ?debug_flag(?loop, exited),
    process_loop(set_status(FinalInfo, exited)).
  
  ets_ownership_exiting_events(Info) ->
  