anchor.diff:      ?dump(ExtraLoadsSum),
       NewExtraLoads = lists:map(
           fun({Node, ExtraLoadSum}) ->
  -            NodeLoad = proplists:get_value(Node, LoadsAndNodes, 0.0),
  -            ExtraLoadsSum / (NodeLoad + ExtraLoadsSum)
  +            {Node, ExtraLoadSum / (1.0 + ExtraLoadSum)}
           end, ExtraLoadsSum),
       ?dump(NewExtraLoads),
       {Result, #load_balancing_state{expected_extra_load = NewExtraLoads}}.
  
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, NodeStates),
      AvgLoadForDisp = average(LoadsForDisp),
      MinLoadForDisp = lists:min(LoadsForDisp),
      NodesAndLoads = lists:zip(Nodes, LoadsForDisp),
      % Nodes that are loaded less than average
      FreeNodes = lists:filter(
          fun({_, Load}) ->
              Load =< AvgLoadForDisp
          end, NodesAndLoads),
      % Nodes that are overloaded
      OverloadedNodes = lists:filtermap(
          fun({Node, Load}) ->
  