anchor.diff:              end
       end.
   
  -get_delayable([], _Time, Delayable) ->
  -    Delayable;
  -    
  -get_delayable([H|T], Time, Delayable) ->
  -    {LabelNext, TimeNext} = H,
  -    case TimeNext=<Time of
  -        true ->
  -            get_delayable(T, Time, Delayable ++ [LabelNext]);
  -        false ->
  -            Delayable
  -    end.
  -
  -filter_labels([], Sendable, _Delay) ->
  -    {Sendable, []};
  -
  -filter_labels([Next|Rest], Sendable, Delay) ->
  -    Now = now_milisec(),
  -    {Label, Time} = Next,
  -    case (Time+Delay)>Now of
  -        true ->
  -            {Sendable, [Next|Rest]};
  -        false ->
  -            filter_labels(Rest, Sendable ++ [Label], Delay)
  -    end.
  -
   now_microsec()->
       %% Not very efficient. os:timestamp() faster but non monotonic. Test!
       {MegaSecs, Secs, MicroSecs} = erlang:now(),
       (MegaSecs * 1000000 + Secs) * 1000000 + MicroSecs.
  -
  -now_milisec() ->
  -    now_microsec()/1000.
  
positive.code:                                                 _ ->
                                                      case groups_manager_serv:interested(Node, BKey) of
                                                          {ok, true} ->
                                                              Queue0 = dict:fetch(Node, Acc1),
                                                              Queue1 = queue:in({Label, Now}, Queue0),
                                                              dict:store(Node, Queue1, Acc1);
                                                          {ok, false} -> Acc1
                                                      end
                                              end
                                          end, Acc0, dict:fetch_keys(Queues0))
                            end, Queues0, Stream),
      S1 = lists:foldl(fun(Node, State) ->
                          deliver_labels(Node, State)
                       end, S0#state{queues=Queues1}, dict:fetch_keys(Queues1)),
      {reply, ok, S1};
  
  handle_call(_Request, _From, State) ->
      {reply, ok, State}.
  
negative.code: %% ------------------------------------------------------------------
  %% Internal Function Definitions
  %% ------------------------------------------------------------------
  deliver_labels(Queue0, Node, MyId, Deliverables0) ->
      Now = saturn_utilities:now_microsec(),
      case queue:out(Queue0) of
          {empty, Queue0} ->
              propagate_stream(Node, lists:reverse(Deliverables0), MyId),
              {Queue0, false};
          {{value, {Time, Label}}, Queue1} when Time =< Now ->
              deliver_labels(Queue1, Node, MyId, [Label|Deliverables0]);
          {{value, {Time, _Label}}, _Queue1} ->
              propagate_stream(Node, lists:reverse(Deliverables0), MyId),
              NextDelivery = trunc((Time - Now)/1000),
              erlang:send_after(NextDelivery, self(), {deliver_labels, Node}),
              {Queue0, true}
      end.
                 
  propagate_stream(_Node, [], _MyId) ->
      done;
  
  propagate_stream(Node, Stream, MyId) ->
      lager:info("Stream to propagate to ~p: ~p", [Node, Stream]),
      case ?PROPAGATION_MODE of
          naive_erlang ->
              case groups_manager_serv:is_leaf(Node) of
  