anchor.diff:      % responses. The bigger the load, the less often should the node appear.
       NodesAndFrequency = [{NodeIP, MinLoadForDNS / Load} || {Load, {_, NodeIP}} <- NotOverloaded],
       FrequencySum = lists:foldl(fun({_, Freq}, Acc) -> Acc + Freq end, 0.0, NodesAndFrequency),
  -    NormalizedNodesAndFrequency = [{NodeIP, Freq / FrequencySum, 0} || {NodeIP, Freq} <- NodesAndFrequency],
  -    NodeChoices = [NodeIP || {NodeIP, _, _} <- NormalizedNodesAndFrequency],
  +    NormalizedNodesAndFrequency = [{NodeIP, Freq / FrequencySum} || {NodeIP, Freq} <- NodesAndFrequency],
  +    NodeChoices = [NodeIP || {NodeIP, _} <- NormalizedNodesAndFrequency],
       NodeChoicesDuplicated = NodeChoices ++ NodeChoices,
       Result = lists:map(
           fun({_, {Node, _}}) ->
  
positive.code: -spec choose_nodes_for_dns(DSNAdvice :: #dns_lb_advice{}) ->
      {[{A :: byte(), B :: byte(), C :: byte(), D :: byte()}], #dns_lb_advice{}}.
  choose_nodes_for_dns(DNSAdvice) ->
      #dns_lb_advice{request_count = ReqCount, nodes_and_frequency = NodesAndFreq,
          node_choices = NodeChoices} = DNSAdvice,
      Index = choose_index(NodesAndFreq, ReqCount),
      Nodes = lists:sublist(NodeChoices, Index, length(NodesAndFreq)),
      [FirstNode | _] = Nodes,
      NewNodesAndFreq = lists:map(
          fun({Node, Freq, ReqCount}) ->
              case Node of
                  FirstNode -> {Node, Freq, ReqCount + 1};
                  _ -> {Node, Freq, ReqCount}
              end
          end, NodesAndFreq),
      {Nodes, DNSAdvice#dns_lb_advice{nodes_and_frequency = NewNodesAndFreq, request_count = ReqCount + 1}}.
  
  
  %%--------------------------------------------------------------------
  
negative.code:         false ->
              node();
          true ->
              Index = choose_index(NodesAndFreq),
              {Node, _} = lists:nth(Index, NodesAndFreq),
              Node
      end.
  
  
  