anchor.diff:  timestamp() ->
           {Mega, Sec, Micro} = now(),
           TS = Mega * 1000000 * 1000000 + Sec * 1000000 + Micro,
  -        <<TS:64/native-integer>>.
  +        <<TS:64/big-integer>>.
  +
  +timestamp_wrapper() ->
  +    {call,?MODULE,timestamp,[]}.
   
   %timestamp() ->
   %    % Returns time in microseconds since epoch
  
positive.code:  
  last_entry_at(StreamID,Time) ->
      Message = list_to_binary([ <<StreamID:16>>, Time]),
  %    Message = list_to_binary([ <<StreamID:16>>, <<Time:64>>]),
      tcp_query(?HOST,?PORT,packet(?LAST_ENTRY_AT,Message)).
  
  %%-----------------------------------------------------------------------------
  
negative.code: % define the commands to test
  command(S) ->
      oneof([
          {call,?MODULE,request_stream,[streamname()]},
  %        {call,?MODULE,request_stream_with_size,[pos_integer(),streamname()]},
  %        {call,?MODULE,append,[streamid(S),list(integer(32,255))]},
          {call,?MODULE,simple_query,[streamid(S),S#state.starttime,timestamp_wrapper()]}%,
  %        {call,?MODULE,all_since,[streamid(S),S#state.starttime]},
  %        {call,?MODULE,last_entry_at,[streamid(S),timestamp_wrapper()]}
      ]).
  
  % define when a command is valid
  precondition(S, {call,?MODULE,simple_query,[StreamID,_Start,_End]}) ->
  %    Bool=lists:keymember(StreamID,1,S#state.streams),
      io:format("~nS: ~p~n~n",[S]),
  %    io:format("StreamID: ~p~n",[StreamID]),
  %    io:format("~nStreams: ~p~n",[S#state.streams]),
  %    io:format("Bool: ~p~n~n",[Bool]),
      lists:keymember(StreamID,1,S#state.streams);
  precondition(_S, _Command) ->
      true.
  
  %% define the state transitions triggered
  %% by each command
  %next_state(S,{ok,<<_,ID>>},{call,?MODULE,request_stream_with_size,[_Size,StreamName]}) ->
  %    case lists:keymember(StreamName,2,S#state.streams) of
  %        false ->
  %            S#state{
  %                streams = [{ID, StreamName, []}|S#state.streams]
  %            };
  %        true ->
  %            S
  %    end;
  %next_state(S,_V,{call,?MODULE,append,[StreamID,Data]}) ->
  %    OldTuple = lists:keysearch(StreamID,1,S#state.streams),
  %    case OldTuple of
  %        {value, {StreamID,StreamName,OldData}} ->
  %            NewTuple = {StreamID,StreamName,[{timestamp(),Data}|OldData]},
  %            S#state{
  %                streams = lists:keyreplace(StreamID,1,S#state.streams,NewTuple)
  %            };
  %        false ->
  %            S
  %    end;
  next_state(S,{ok,<<_,ID>>},{call,?MODULE,request_stream,[StreamName]}) ->
      case lists:keymember(StreamName,2,S#state.streams) of
          false ->
              S#state{
  