anchor.diff:  		 %orelse node_details:get(HeavyNode, node) =:= node_details:get(LightNode, pred) of
   		true ->
   			% neighbors, thus sliding
  -			?TRACE("We're neighbors~n"),
  +			?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
  -			?TRACE("Nodes not adjacent, requesting information about neighbors~n"),
  +			?TRACE1("Nodes not adjacent, requesting information about neighbors~n"),
   			comm:send(node:pidX(LightNodeSucc), {balance_load, phase2, HeavyNodeDetails, LightNodeDetails})
   	end.
   
  
positive.code: 			if
      % first check if load balancing is necessary
  				MyLoad =< Epsilon * LoadX ->
  					?TRACE("My node is light~n"),
  					balance_adjacent(NodeX, MyLBInfo);
  				LoadX =< Epsilon * MyLoad ->
  					?TRACE("My node is heavy~n"),
  					balance_adjacent(MyLBInfo, NodeX);
  				true ->
  					%% no balancing
  					?TRACE("Won't balance~n")
  			end;
  		_ -> ok
  	end,
  
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) ->
  	?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),
  	?TRACE2("TargetLoad: ~p TakenLoad: ~p~n",
              [TargetLoad, _TakenLoad]),
  	LbModule = comm:make_global(pid_groups:get_my(?MODULE)),
  	case JumpOrSlide of
  