anchor.diff:                  false ->
                       noop
               end,
  -            flush_queue(Rest, S0);
  +            true;
           update ->
  -            case dict:find(Label, Ops0) of
  -                {ok, Value} ->
  +            case ets:lookup(Ops, Label) of
  +                [{Label, Value}] ->
                       ok = execute_operation(Label, Value),
  -                    Ops1 = dict:erase(Label, Ops0),
  -                    flush_queue(Rest, S0#state{ops_dict=Ops1});
  -                _ ->
  +                    true = ets:delete(Ops, Label),
  +                    true;
  +                [] ->
                       lager:info("Operation not received for label: ~p", [Label]),
  -                    S0#state{labels_queue=queue:from_list(Labels)}
  +                    false
               end
       end.
   
  
positive.code:     gen_server:call({global, reg_name(MyId)}, Message, infinity).
  
  init([MyId]) ->
      {ok, #state{labels_queue=queue:new(),
                  ops_dict=dict:new(),
                  myid=MyId}}.
  
  handle_call({new_stream, Stream, _SenderId}, _From, S0=#state{labels_queue=Labels0, ops_dict=_Ops0}) ->
      %lager:info("New stream received. Label: ~p", Stream),
      case queue:len(Labels0) of
          0 ->
              S1 = flush_queue(Stream, S0);
          _ ->
              Labels1 = queue:join(Labels0, queue:from_list(Stream)),
              S1 = S0#state{labels_queue=Labels1}
      end,
      {reply, ok, S1};
  
  handle_call({new_operation, Label, Value}, _From, S0=#state{labels_queue=Labels0, ops_dict=Ops0}) ->
      %lager:info("New operation received. Label: ~p", [Label]),
      case queue:peek(Labels0) of
          {value, Label} ->
              ok = execute_operation(Label, Value),
              Labels1 = queue:drop(Labels0),
              S1 = flush_queue(queue:to_list(Labels1), S0);
          _ ->
              Ops1 = dict:store(Label, Value, Ops0),
              S1 = S0#state{ops_dict=Ops1}
      end,
      {reply, ok, S1}.
  
  handle_cast(_Info, State) ->
      {noreply, State}.
  
negative.code:     [{IndexNode, _Type}] = PrefList,
      saturn_proxy_vnode:propagate(IndexNode, BKey, Value, Clock).
  
  flush_list([], _Ops, _MyId) ->
      {queue:new(), 0};
  
  flush_list([Label|Rest]=List, Ops, MyId) ->
      case handle_label(Label, Ops, MyId) of
          true ->
              flush_list(Rest, Ops, MyId);
          false ->
              {queue:from_list(List), length(List)}
      end.
  
  flush_queue(Queue, Length, Ops, MyId) ->
      case queue:peek(Queue) of
          {value, Label} ->
              case handle_label(Label, Ops, MyId) of
                  true ->
                      flush_queue(queue:drop(Queue), Length - 1, Ops, MyId);
                  false ->
                      {Queue, Length}
              end;
          _ ->
              {queue:new(), 0}
      end.
  
  handle_label(Label, Ops, MyId) ->
      case Label#label.operation of
          remote_read ->
              Payload = Label#label.payload,
  