anchor.diff:                  end,
               {Node, #dispatcher_lb_advice{should_delegate = ShouldDelegate,
                   nodes_and_frequency = NodesAndFrequency, all_nodes = Nodes}}
  -        end, LoadsAndNodes),
  +        end, NodesAndLoads),
       ?dump(Result),
  -    % Calculate expected extra loads on each node. For example:
  +    % 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_A_load
  -    % node B = -------------------------------
  -    %          node_B_load + 0.7 * node_A_load
  +    %             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) ->
  
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:                 false -> false;
                  true -> {true, Node}
              end
          end, NodesAndLoads),
      OverloadedNodesNum = length(OverloadedNodes),
      Result = lists:map(
          fun({Node, Load}) ->
  