anchor.diff:  
   %% No random nodes available via cyclon
   on({cy_cache, []}, State) ->
  -    ?TRACE1("Cyclon returned no random node~n"),
  +    ?TRACE("Cyclon returned no random node~n"),
       State;
   
   %% Got a random node via cyclon
   on({cy_cache, [RandomNode]}, State) ->
  -    ?TRACE1("Got random node~n"),
  -    LocalPid = pid_groups:get_my(dht_node),
  -	GlobalPid = comm:make_global(LocalPid),
  -	Envelope = comm:reply_as(comm:this(), 2, {my_dht_response, '_'}),
  -    comm:send(GlobalPid, {get_node_details, Envelope}),
  +    ?TRACE("Got random node~n"),
  +    Envelope = comm:reply_as(comm:this(), 2, {my_dht_response, '_'}),
  +    comm:send(comm:this(), {get_node_details, Envelope}, [{group_member, dht_node}]),
       State#state{rnd_node = RandomNode};
   
   %% Got load from my node
   on({my_dht_response, {get_node_details_response, NodeDetails}}, State) ->
  -	?TRACE1("Received node details for own node~n"),
  +	?TRACE("Received node details for own node~n"),
   	RndNode = State#state.rnd_node,
   	Epsilon = State#state.epsilon,
  -	comm:send(node:pidX(RndNode), {balance_load, phase1, Epsilon, serialize(NodeDetails)}, [{shepherd, self()}]),
  - 	State#state{rnd_node = nil};
  -
  -on({move, result, {tag, JumpOrSlide}, Status}, State) ->
  -	?TRACE2("~p status: ~p~n", [JumpOrSlide, Status]),
  -	State;
  -
  -on({send_error, Pid, Msg, Reason}, State) ->
  -    %% send errors occur when cyclon returns outdated
  -    %% node information. In case of jumps this happens
  -    %% quite often.
  -    ?TRACE2("Failed to send message to ~p because of ~p: ~n~p~n", 
  -            [Pid, Reason, Msg]),
  -    State.
  +	comm:send(node:pidX(RndNode), {balance_load, phase1, Epsilon, serialize(NodeDetails)}, [{?quiet}]),
  +	State#state{rnd_node = nil};
  +
  +on({move, result, {tag, _JumpOrSlide}, _Status}, State) ->
  +	?TRACE("~p status: ~p~n", [_JumpOrSlide, _Status]),
  +	State.
   
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   %%  Static methods called by dht_node message handler  %
  
positive.code: %% LightNode. Otherwise we instruct the HeavyNode to set up
  %% a jump operation with the Lightnode.
  process_lb_msg({balance_load, phase2, HeavyNode, LightNode}, DhtState) ->
  	?TRACE1("In phase 2~n"),
  	MyLBInfo = serialize(dht_node_state:details(DhtState)),
  	MyLoad = get_load(MyLBInfo),
  	LoadHeavyNode = get_load(HeavyNode),
  	case MyLoad > LoadHeavyNode of
  		true ->
  			balance_adjacent(MyLBInfo, LightNode); %% TODO safe to call this?
  		_ ->
  			Node = get_node(HeavyNode),
  			comm:send(node:pidX(Node), {balance_load, jump, LightNode})
  
negative.code: %% In either case, we'll compute the target id and send out
  %% the jump or slide message to the LightNode.
  process_lb_msg({balance_load, JumpOrSlide, LightNode}, DhtState) ->
  	?TRACE("Before ~p Heavy: ~p Light: ~p~n",
              [JumpOrSlide, dht_node_state:get(DhtState, node_id), node:id(get_node(LightNode))]),
  	MyNode = serialize(dht_node_state:details(DhtState)),
  	TargetLoad = get_target_load(JumpOrSlide, MyNode, LightNode),
      From = dht_node_state:get(DhtState, pred_id),
  	To = dht_node_state:get(DhtState, node_id),
  	{SplitKey, _TakenLoad} = dht_node_state:get_split_key(DhtState, From, To, TargetLoad, forward),
  	?TRACE("TargetLoad: ~p TakenLoad: ~p~n",
              [TargetLoad, _TakenLoad]),
  	LbModule = comm:make_global(pid_groups:get_my(?MODULE)),
  	case JumpOrSlide of
  		jump ->
  			Node = get_node(LightNode),
  			comm:send(node:pidX(Node), {move, start_jump, SplitKey, {tag, JumpOrSlide}, LbModule});
  		slide ->
  			Node = get_node(LightNode),
  			comm:send(node:pidX(Node),{move, start_slide, succ, SplitKey, {tag, JumpOrSlide}, LbModule})
  	end,
  	DhtState.
  