anchor.diff:      end;
   handle_call(status, _,
               #state{mode = Mode,
  +                   mode_sync_start = SyncStart,
  +                   mode_sync_start_event = SyncStartEvent,
  +                   mode_sync_end = SyncEnd,
  +                   mode_sync_end_event = SyncEndEvent,
  +                   mode_sync_total = SyncTotal,
  +                   mode_overload_start = OverloadStart,
  +                   mode_overload_start_event = OverloadStartEvent,
  +                   mode_overload_end = OverloadEnd,
  +                   mode_overload_end_event = OverloadEndEvent,
  +                   mode_overload_total = OverloadTotal,
                      file_counts = FileCounts,
                      error_read_count = ErrorReadCount,
                      error_read_types = ErrorReadTypes,
                      error_write_count = ErrorWriteCount,
                      error_write_types = ErrorWriteTypes,
                      error_sync_count = ErrorSyncCount,
  -                   error_sync_types = ErrorSyncTypes,
  -                   sync_start = SyncStart,
  -                   sync_start_event = SyncStartEvent,
  -                   sync_end = SyncEnd,
  -                   sync_end_event = SyncEndEvent,
  -                   sync_total = SyncTotal,
  -                   overload_start = OverloadStart,
  -                   overload_start_event = OverloadStartEvent,
  -                   overload_end = OverloadEnd,
  -                   overload_end_event = OverloadEndEvent,
  -                   overload_total = OverloadTotal} = State) ->
  +                   error_sync_types = ErrorSyncTypes} = State) ->
       TimeOffset = erlang:time_offset(),
       Status0 = if
           ErrorReadCount > 0 ->
  
positive.code:     {ok, State#state{queue_pending = QueuePending - 1}}.
  
  log_mode_changed(sync, async, Timestamp, State) ->
      {ok, State#state{sync_start = cloudi_timestamp:native_monotonic(),
                       sync_start_event = timestamp_iso8601(Timestamp),
                       sync_end = undefined,
                       sync_end_event = undefined,
                       sync_total = undefined}};
  log_mode_changed(async, sync, Timestamp,
                   #state{sync_start = SyncStart} = State) ->
      SyncEnd = cloudi_timestamp:native_monotonic(),
      SyncNanoSeconds = cloudi_timestamp:
                        convert(SyncEnd - SyncStart,
                                native, nanosecond),
      SyncTotal = cloudi_timestamp:
                  nanoseconds_to_string(SyncNanoSeconds),
      {ok, State#state{sync_end = SyncEnd,
                       sync_end_event = timestamp_iso8601(Timestamp),
                       sync_total = SyncTotal}};
  log_mode_changed(overload, sync, Timestamp, State) ->
      {ok, State#state{overload_start = cloudi_timestamp:native_monotonic(),
                       overload_start_event = timestamp_iso8601(Timestamp),
                       overload_end = undefined,
                       overload_end_event = undefined,
                       overload_total = undefined}};
  log_mode_changed(sync, overload, Timestamp,
                   #state{overload_start = OverloadStart} = State) ->
      OverloadEnd = cloudi_timestamp:native_monotonic(),
      OverloadNanoSeconds = cloudi_timestamp:
                            convert(OverloadEnd - OverloadStart,
                                    native, nanosecond),
      OverloadTotal = cloudi_timestamp:
                      nanoseconds_to_string(OverloadNanoSeconds),
      StateNew = State#state{overload_end = OverloadEnd,
                             overload_end_event = timestamp_iso8601(Timestamp),
                             overload_total = OverloadTotal},
      ?LOG_T0_ERROR("logging overload occurred for ~s",
                    [OverloadTotal], StateNew);
  log_mode_changed(_, _, _, State) ->
  
negative.code:     {reply, {ok, StatusN}, State};
  handle_call(status_reset, _, State) ->
      {reply, ok,
       State#state{mode_sync_start = undefined,
                   mode_sync_start_event = undefined,
                   mode_sync_end = undefined,
                   mode_sync_end_event = undefined,
                   mode_sync_total = undefined,
                   mode_overload_start = undefined,
                   mode_overload_start_event = undefined,
                   mode_overload_end = undefined,
                   mode_overload_end_event = undefined,
                   mode_overload_total = undefined,
                   file_counts = #{},
                   error_read_count = 0,
                   error_read_types = [],
                   error_write_count = 0,
                   error_write_types = [],
                   error_sync_count = 0,
                   error_sync_types = []}};
  handle_call(Request, _, State) ->
      {stop, cloudi_string:format("Unknown call \"~w\"", [Request]),
       error, State}.
  