anchor.diff:  %% 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",
  +	?TRACE2("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",
  +	?TRACE2("TargetLoad: ~p TakenLoad: ~p~n",
               [TargetLoad, _TakenLoad]),
   	LbModule = comm:make_global(pid_groups:get_my(?MODULE)),
   	case JumpOrSlide of
  
positive.code: 
  %% No random nodes available via cyclon
  on({cy_cache, []}, State) ->
      ?TRACE("Cyclon returned no random node~n"),
      State;
  
  %% Got a random node via cyclon
  on({cy_cache, [RandomNode]}, State) ->
      ?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) ->
  	?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)}, [{?quiet}]),
  	State#state{rnd_node = nil};
  
  on({move, result, {tag, _JumpOrSlide}, _Status}, State) ->
  	?TRACE("~p status: ~p~n", [_JumpOrSlide, _Status]),
  	State.
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
negative.code: 		 %orelse node_details:get(HeavyNode, node) =:= node_details:get(LightNode, pred) of
  		true ->
  			% neighbors, thus sliding
  			?TRACE1("We're neighbors~n"),
              %% slide in phase1 or phase2
  			comm:send(node:pidX(HeavyNode), {balance_load, slide, LightNodeDetails});
  		_ ->
  			% ask the successor of the light node how much load he carries
  			?TRACE1("Nodes not adjacent, requesting information about neighbors~n"),
  			comm:send(node:pidX(LightNodeSucc), {balance_load, phase2, HeavyNodeDetails, LightNodeDetails})
  	end.
  
  