anchor.diff:  -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,
  +    #dns_lb_advice{nodes_and_frequency = NodesAndFreq,
           node_choices = NodeChoices} = DNSAdvice,
  -    Index = choose_index(NodesAndFreq, ReqCount),
  +    Index = choose_index(NodesAndFreq),
       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}}.
  +    Nodes.
   
   
   %%--------------------------------------------------------------------
  
positive.code:     % 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],
      NodeChoicesDuplicated = NodeChoices ++ NodeChoices,
      Result = lists:map(
          fun({_, {Node, _}}) ->
  
negative.code: %% @private
  %% @doc
  %% Helper function that returns the index of node which should be chosen based on
  %% frequency (weights) of nodes.
  %% @end
  %%--------------------------------------------------------------------
  -spec choose_index(NodesAndFrequencies :: [{Node :: term(), Frequency :: float()}]) -> integer() when .
  choose_index(NodesAndFrequencies) ->
      random:seed(now()),
      choose_index(NodesAndFrequencies, 0, random:uniform()).
  
  choose_index([], CurrIndex, _) ->
      CurrIndex;
  
  choose_index(_, CurrIndex, RandomFloat) when RandomFloat < 0.0 ->
      CurrIndex;
  
  choose_index([{_, Freq} | T], CurrIndex, RandomFloat) ->
      choose_index(T, CurrIndex + 1, RandomFloat - Freq).
  
  
  %%     {_, Index, _} = lists:foldl(
  %%         fun({_, Frequency, CurrReqCount}, {AccIndex, AccChoice, AccValue}) ->
  %%             Value = Frequency * RequestCount - CurrReqCount,
  %%             {NewChoice, NewValue} = case Value > AccValue of
  %%                                         false -> {AccChoice, AccValue};
  %%                                         true -> {AccIndex, Value}
  %%                                     end,
  %%             {AccIndex + 1, NewChoice, NewValue}
  %%         end, {1, 0, -9999999}, NodesAndFrequencies),
  %%     Index.
  
  %%--------------------------------------------------------------------
  %% @private
  