anchor.diff:                  false -> false;
                   true -> {true, Node}
               end
  -        end, LoadsAndNodes),
  +        end, NodesAndLoads),
       OverloadedNodesNum = length(OverloadedNodes),
       Result = lists:map(
           fun({Node, Load}) ->
  
positive.code:                     ExtraLoadsAcc;
                  true ->
                      lists:foldl(
                          fun({NodeTo, Freq}, Acc) ->
                              case NodeFrom of
                                  NodeTo ->
                                      Acc;
                                  _ ->
                                      Current = proplists:get_value(NodeTo, Acc, 0.0),
                                      NodeToLoad = proplists:get_value(NodeTo, LoadsAndNodes, 0.0),
                                      [{NodeTo, Current + NodeToLoad * Freq} | proplists:delete(NodeTo, Acc)]
                              end
                          end, ExtraLoadsAcc, NodesAndFreq)
              end
  
negative.code:                 end,
              {Node, #dispatcher_lb_advice{should_delegate = ShouldDelegate,
                  nodes_and_frequency = NodesAndFrequency, all_nodes = Nodes}}
          end, NodesAndLoads),
      ?dump(Result),
      % Calculate expected extra loads on each node.
      % For example:
      % node A is overloaded and will delegate 70% reqs to node B
      % node B in not overloaded
      % expected extra load on each node is:
      % node A = 0.0
      %             0.7
      % node B = ---------
      %          1.0 + 0.7
      %
      % (1.0 is expected normal load on node B, as it does not delegate anything)
      %
      ExtraLoadsSum = lists:foldl(
          fun({NodeFrom, DispLBAdvice}, ExtraLoadsAcc) ->
  