anchor.diff:                          Ticket = create_ticket(Error, LidTrace),
                           %% Report error
                           concuerror_log:progress({'error', Ticket}),
  -                        {[Ticket|Tickets], SBlocked}
  +                        {[Ticket|Tickets], SBlocked, SleepTrans}
                   end;
               _Else ->
                   case TraceTop#trace_state.sleep_set =/= []
                       andalso TraceTop#trace_state.done =:= [] of
                       false ->
  -                        {Tickets, SBlocked};
  +                        {Tickets, SBlocked, SleepTrans};
                       true ->
                           ?debug("SLEEP SET BLOCK\n"),
                           %% debug_trace(lists:reverse(Trace)),
                           %% exit(sleep_set_block),
  -                        {Tickets, SBlocked+1}
  +                        {Tickets, SBlocked+1, SleepTrans+Steps}
                   end
           end,
       State#dpor_state{must_replay = true, tickets = NewTickets,
  -                     sleep_blocked_count = NewSBlocked}.
  +                     sleep_blocked_count = NewSBlocked,
  +                     total_trans = NewTotalTrans,
  +                     sleep_trans = NewSleepTrans}.
   
   %% debug_trace([]) -> ok;
   %% debug_trace([Top|Rest]) ->
  
positive.code:                 {Mins, Secs} = concuerror_util:to_elapsed_time(T1, T2),
                  ?debug("Done in ~wm~.2fs\n", [Mins, Secs]),
                  %% Print analysis summary
                  RunCount = element(2, Result),
                  SBlocked = element(3, Result),
                  StrB =
                      case SBlocked of
                          0 -> " ";
                          _ -> io_lib:format(
                                  " (encountered ~w sleep-set blocked traces) ",
                                  [SBlocked])
                      end,
                  concuerror_log:log(0, "\n\nAnalysis complete. Checked "
                      "~w interleaving(s)~sin ~wm~.2fs:\n",
                      [RunCount, StrB, Mins, Secs]),
                  case Result of
                      {ok, _, _} ->
                          concuerror_log:log(0, "No errors found.~n"),
                          {ok, {Target, RunCount, SBlocked}};
                      {error, _, _, Tickets} ->
                          TicketCount = length(Tickets),
                          concuerror_log:log(0,
                                  "Found ~p erroneous interleaving(s).~n",
  
negative.code: %% -----------------------------------------------------------------------------
  
  report_error(Transition, State) ->
      #dpor_state{trace = [TraceTop|_] = Trace, tickets = Tickets,
                  total_trans = TotalTrans} = State,
      #trace_state{i = Steps} = TraceTop,
      NewTotalTrans = TotalTrans + Steps,
      ?debug("ERROR!\n~P\n",[Transition, ?DEBUG_DEPTH]),
      Error = convert_error_info(Transition),
      LidTrace = convert_trace_to_error_trace(Trace, [Transition]),
      Ticket = create_ticket(Error, LidTrace),
      %% Report the error to the progress logger.
      concuerror_log:progress({'error', Ticket}),
      State#dpor_state{must_replay = true, tickets = [Ticket|Tickets],
                       total_trans = NewTotalTrans}.
  
  report_possible_deadlock(#dpor_state{trace = []} = State) -> State;
  report_possible_deadlock(State) ->
      #dpor_state{trace = [TraceTop|_] = Trace, tickets = Tickets,
                  sleep_blocked_count = SBlocked,
                  total_trans = TotalTrans, sleep_trans = SleepTrans} = State,
      #trace_state{i = Steps} = TraceTop,
      NewTotalTrans = TotalTrans + Steps,
      {NewTickets, NewSBlocked, NewSleepTrans} =
          case TraceTop#trace_state.enabled of
              [] ->
                  case TraceTop#trace_state.blocked of
                      [] ->
                          ?debug("NORMAL!\n"),
                          {Tickets, SBlocked, SleepTrans};
                      Blocked ->
                          ?debug("DEADLOCK!\n"),
                          Error = {deadlock, Blocked},
  