anchor.diff:  % for debugging
   handle_call(nci_details, _From, State = #?STATE{community_data = CommunityData,
                                                   nci = NCI,
  -                                                last_nci_time = Time}) ->
  -    {reply, json_nci_details(Time, NCI, CommunityData), State};
  +                                                last_nci_time = Time,
  +                                                limits = Limits}) ->
  +    {reply, json_nci_details(Time, NCI, CommunityData, Limits), State};
   handle_call(collectors, _From, State = #?STATE{collectors = CollectorDict,
                                                  last_qps_time = Time}) ->
       {reply, json_collectors(Time, CollectorDict), State};
  
positive.code: handle_cast({nci_details, Pid}, State = #?STATE{
                                              community_data = CommunityData,
                                              nci = NCI,
                                              last_nci_time = Time}) ->
      clientsock:send(Pid, json_nci_details(Time, NCI, CommunityData)),
      {noreply, State};
  handle_cast({collectors, Pid}, State = #?STATE{collectors = CollectorDict,
                                                 last_qps_time = Time}) ->
  
negative.code: cendpoints(Endpoints, Sizes) ->
      lists:map(fun(E) -> cendpointsize(E, Sizes) end, Endpoints).
  
  cinteractions(Interactions, CommunityList, Sizes) ->
      CommunitySet = sets:from_list(CommunityList),
      lists:foldl(
          fun({C1, C2}, L) ->
              case sets:is_element(C1, CommunitySet) andalso
                   sets:is_element(C2, CommunitySet) of
                  true ->
                      [[cendpointsize(C1, Sizes),
                       cendpointsize(C2, Sizes)] | L];
                  false ->
                      L
              end
          end, [], Interactions).
  
  dict_value_length(D) ->
      dict:fold(fun(_, List, Sum) -> Sum + length(List) end, 0, D).
  
  community_details(no_communities, _CommunityList, _Limits) ->
      [];
  community_details({{EndpointsD, InteractionsD}, SizesD, _Comms},
                                                      CommunityList, Limits) ->
      MaxCommunitySize = proplists:get_value(comm_size_limit, Limits),
      MaxVertices = proplists:get_value(max_vertices, Limits),
      MaxEdges = proplists:get_value(max_edges, Limits),
      EdgeCount = dict_value_length(InteractionsD),
      VertexCount = dict_value_length(EndpointsD),
      OverLimit = overlimit(EdgeCount, MaxEdges) orelse overlimit(VertexCount, MaxVertices),
      lists:foldl(
          fun(C, L) ->
              Interactions = dict_fetch(C, InteractionsD),
              Endpoints = dict_fetch(C, EndpointsD),
              D = case OverLimit orelse
                          overlimit(length(Endpoints), MaxCommunitySize) of
                  true ->
                      {[
                          {<<"Interactions">>, []},
                          {<<"Endpoints">>, []},
                          {<<"Label">>, endpoint(C)},
                          {<<"Size">>, dict:fetch(C, SizesD)}
                      ]};
                  false ->
                      {[
                          {<<"Interactions">>, interactions(Interactions, Endpoints)},
                          {<<"Endpoints">>, endpoints(Endpoints)},
                          {<<"Label">>, endpoint(C)},
                          {<<"Size">>, dict:fetch(C, SizesD)}
                      ]}
              end,
              [D | L]
          end, [], CommunityList).
  
  overlimit(_, 0) ->
      false;
  overlimit(_, inifinity) ->
      false;
  overlimit(Value, Max) ->
      Value > Max.
  
  dict_fetch(Key, Dict) ->
      case dict:find(Key, Dict) of
  