anchor.diff:          _ ->
               io:format("Total difference:~n"),
               bitmap:display_diff(Union, Intersection, Width),
  -            io:format("~n"),
  -            show_diff(Results, Union, Width)
  +            show_diff(Results, Union, Width),
  +            io:format("~n")
       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([{Node, P, not_found} | R], Union, Width) ->
  +    io:format("~n=== ~s (~p)~n  This node had no data~n", [Node, P]),
       show_diff(R, Union, Width);
  -show_diff([{Node, Union} | R], Union, Width) ->
  -    io:format("~n=== ~s~n"
  -              "* No missing points~n", [Node]),
  +show_diff([{Node, P, Union} | R], Union, Width) ->
  +    io:format("~n=== ~s (~p)~n"
  +              "* No missing points~n", [Node, P]),
       show_diff(R, Union, Width);
  -show_diff([{Node, Bitmap} | R], Union, Width) ->
  -    io:format("~n=== ~s~n", [Node]),
  +show_diff([{Node, P, Bitmap} | R], Union, Width) ->
  +    io:format("~n=== ~s (~p)~n", [Node, P]),
       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, not_found, [{_, _, B0} | R])->
       calc_f(F, B0, R);
  -calc_f(F, B0, [{_, not_found} | R]) ->
  +calc_f(F, B0, [{_, _, not_found} | R]) ->
       calc_f(F, B0, R);
  -calc_f(F, B0, [{_, B1} | 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) ->
  +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]);
  +            get_nodes(R, Bucket, Metric, Time, [{N, P, BMP} | Acc]);
           _O ->
  -            get_nodes(R, Bucket, Metric, Time, [{N, not_found} | Acc])
  +            get_nodes(R, Bucket, Metric, Time, [{N, P, not_found} | Acc])
       end.
   
   show_bitmap(TimeS, BucketS, MetricS, Width) ->
  
positive.code:     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
          [] ->
              io:format("No valid node found, try on: ~p~n",
                        [[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")
      end.
  
  get_nodes(Bucket, Metric, Time) ->
  
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
  