anchor.diff:      MetricL = [list_to_binary(M) || M <- MetricS],
       Metric = dproto:metric_from_list(MetricL),
       Nodes =  get_bmps(Bucket, Metric, Time),
  -    case [BMP || {Node, BMP} <- Nodes, Node =:= node()] of
  +    case [{P, BMP} || {Node, P, BMP} <- Nodes, Node =:= node()] of
           [] ->
               io:format("No valid node found, try on: ~p~n",
  -                      [[Node || {Node, _} <- Nodes]]),
  +                      [[Node || {Node, _, _} <- Nodes]]),
               error;
  -        [not_found] ->
  -            io:format("No data for this time range~n"),
  -            error;
  -        [BMP | _]  ->
  -            io:format("=== ~s~n", [string:join(MetricS, ".")]),
  -            bitmap:display(BMP, Width),
  -            io:format("~n")
  +        L ->
  +            lists:map(fun({P, not_found}) ->
  +                               io:format("=== ~p~n", [P]),
  +                               io:format("* No data for this time range~n");
  +                          ({P, BMP}) ->
  +                               io:format("=== ~s~n", [P]),
  +                               bitmap:display(BMP, Width),
  +                               io:format("~n")
  +                       end, L)
       end.
   
   get_nodes(Bucket, Metric, Time) ->
  
positive.code:         _ ->
              io:format("Total difference:~n"),
              bitmap:display_diff(Union, Intersection, Width),
              io:format("~n"),
              show_diff(Results, Union, Width)
      end.
  
  show_diff([], _Union, _Width) ->
      ok;
  show_diff([{Node, not_found} | R], Union, Width) ->
      io:format("~n=== ~s~n  This node had no data~n", [Node]),
      show_diff(R, Union, Width);
  show_diff([{Node, Union} | R], Union, Width) ->
      io:format("~n=== ~s~n"
                "* No missing points~n", [Node]),
      show_diff(R, Union, Width);
  show_diff([{Node, Bitmap} | R], Union, Width) ->
      io:format("~n=== ~s~n", [Node]),
      bitmap:display_diff(Union, Bitmap, Width),
      show_diff(R, Union, Width).
  
  calc_f(_F, R, []) ->
      R;
  calc_f(F, not_found, [{_, B0} | R])->
      calc_f(F, B0, R);
  calc_f(F, B0, [{_, not_found} | R]) ->
      calc_f(F, B0, R);
  calc_f(F, B0, [{_, B1} | R]) ->
      calc_f(F, F(B0, B1), R).
  
  get_nodes([], _Bucket, _Metric, _Time, Acc) ->
      Acc;
  get_nodes([{_P, N} = PN | R], Bucket, Metric, Time, Acc) ->
      case metric_vnode:get_bitmap(PN, Bucket, Metric, Time) of
          {ok, BMP} ->
              get_nodes(R, Bucket, Metric, Time, [{N, BMP} | Acc]);
          _O ->
              get_nodes(R, Bucket, Metric, Time, [{N, not_found} | Acc])
      end.
  
  show_bitmap(TimeS, BucketS, MetricS, Width) ->
  
negative.code:     Time = list_to_integer(TimeS),
      MetricL = [list_to_binary(M) || M <- MetricS],
      Metric = dproto:metric_from_list(MetricL),
      Results = [{_, _, B0} | Rest] = get_bmps(Bucket, Metric, Time),
      Union = calc_f(fun bitmap:union/2, B0, Rest),
      Intersection = calc_f(fun bitmap:intersection/2, B0, Rest),
      case {Union, Intersection} of
  