anchor.diff:      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),
  +    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
  
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:         _ ->
              io:format("Total difference:~n"),
              bitmap:display_diff(Union, Intersection, Width),
              show_diff(Results, Union, Width),
              io:format("~n")
      end.
  
  show_diff([], _Union, _Width) ->
      ok;
  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, 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, 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, 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, P, BMP} | Acc]);
          _O ->
              get_nodes(R, Bucket, Metric, Time, [{N, P, not_found} | Acc])
      end.
  
  show_bitmap(TimeS, BucketS, MetricS, Width) ->
  