anchor.diff:      [print_manifest_summary(RiakcPid, Bucket, SiblingNo, M)
        || Key <- lists:sort(ManifestKeys),
           {SiblingNo, _UUID, M} <- get_manifest(RiakcPid, Bucket, Key)].
  +
  +list_users(RiakcPid)->
  +    io:format("~-40..=s ~-8..=s: ~-40..=s ~-40..=s~n",
  +              ["Key ID ", "Sibl. ", "Name ", "Secret "]),
  +    {ok, Keys} = riakc_pb_socket:list_keys(RiakcPid, "moss.users"),
  +    %% TODO: only support #rcs_user_v2{}
  +    [[io:format("~-40s ~8B: ~-40s ~-40s~n",
  +                [user_attr(key_id, User),
  +                 SiblingNo,
  +                 user_attr(name, User),
  +                 user_attr(key_secret, User)])
  +      || {SiblingNo, {MD, V}} <- get_riak_object(RiakcPid, "moss.users", Key),
  +         User <- [case MD of
  +                      tombstone -> tombstone;
  +                      _ -> binary_to_term(V)
  +                  end]]
  +     || Key <- lists:sort(Keys)].
  +
  +show_user(RiakcPid, Opts) ->
  +    case {proplists:get_value(key, Opts), proplists:get_value(name, Opts)} of
  +        {undefined, undefined} ->
  +            e("Error: --key or --name is required."),
  +            io:nl(),
  +            usage(user, show),
  +            halt(1);
  +        {Key, undefined} ->
  +            print_users(RiakcPid, "moss.users", {key, Key});
  +        {undefined, Name} ->
  +            print_users(RiakcPid, "moss.users", {name, Name})
  +    end.
  +
  +list_accesses(RiakcPid) ->
  +    io:format("~-40..=s ~-8..=s: ~-16..=s ~-16..=s ~-32..=s~n",
  +              ["Key ", "Sibl. ", "StartTime ", "EndTime ", "MossNode "]),
  +    {ok, Keys} = riakc_pb_socket:list_keys(RiakcPid, "moss.access"),
  +    [[io:format("~-40s ~8B: ~-16s ~-16s ~-32s~n",
  +                [Key, SiblingNo, Start, End, Node])
  +      || {SiblingNo, {MD, V}} <- get_riak_object(RiakcPid, "moss.access", Key),
  +         {Start, End, Node, _Stats} <- [case MD of
  +                       tombstone -> tombstone;
  +                       _ -> stats_sample_from_binary(V)
  +                   end]]
  +     || Key <- lists:sort(Keys)].
  +
  +show_access(_RiakcPid, undefined)->
  +    usage(access, show),
  +    halt(1);
  +show_access(RiakcPid, Key)->
  +    [print_access_stats(Key, SiblingNo, StatsBin)
  +     || {SiblingNo, {_RiakMD, StatsBin}}
  +            <- get_riak_object(RiakcPid, "moss.access", Key)].
  +
  +list_gc(RiakcPid, undefined)->
  +    {ok, ManifestKeys} = riakc_pb_socket:list_keys(RiakcPid, "riak-cs-gc"),
  +    list_gc_from_keys(RiakcPid, ManifestKeys);
  +list_gc(RiakcPid, InputFileName)->
  +    {ok, Bin} = file:read_file(InputFileName),
  +    ManifestKeys = binary:split(Bin, <<"\n">>, [global, trim]),
  +    list_gc_from_keys(RiakcPid, ManifestKeys).
  +
  +list_gc_from_keys(RiakcPid, ManifestKeys)->
  +    print_gc_manifest_summary(pid, bucket, sibling_no, header),
  +    [print_gc_manifest_summary(RiakcPid, Key, SiblingNo, M)
  +     || Key <- lists:sort(ManifestKeys),
  +        {SiblingNo, _UUID, M} <- get_gc_manifest(RiakcPid, "riak-cs-gc", Key)].
  +
  +show_gc(_RiakcPid, undefined)->
  +    usage(gc, show),
  +    halt(1);
  +show_gc(RiakcPid, Key)->
  +    Manifests = get_gc_manifest(RiakcPid, "riak-cs-gc", Key),
  +    io:format("----- ~B instance(s) -----~n", [length(Manifests)]),
  +    [ print_manifest(Manifest) || Manifest <- Manifests].
  +
  +list_storage(RiakcPid) -> 
  +    io:format("~-40..=s ~-8..=s: ~-16..=s ~-16..=s~n",
  +              ["Key ", "Sibl. ", "StartTime ", "EndTime "]),
  +    {ok, Keys} = riakc_pb_socket:list_keys(RiakcPid, "moss.storage"),
  +    [[io:format("~-40s ~8B: ~-16s ~-16s~n",
  +                [Key, SiblingNo, Start, End])
  +      || {SiblingNo, {MD, V}} <- get_riak_object(RiakcPid, "moss.storage", Key),
  +         {Start, End, _Node, _Stats} <- [case MD of
  +                       tombstone -> tombstone;
  +                       _ -> stats_sample_from_binary(V)
  +                   end]]
  +     || Key <- lists:sort(Keys)].
  +
  +show_storage(_RiakcPid, undefined)->
  +    usage(storage, show),
  +    halt(1);
  +show_storage(RiakcPid, Key)->
  +    [print_storage_stats(Key, SiblingNo, StatsBin)
  +     || {SiblingNo, {_RiakMD, StatsBin}}
  +            <- get_riak_object(RiakcPid, "moss.storage", Key)].
   
   print_gc_manifest_summary(_RiakcPid, _Key, _SiblingNo, header) ->
       io:format("~-32..=s: ~-8..=s ~-16..=s ~-32..=s ~-16..=s ~-32..=s~n",
  
positive.code:             riakc_obj:get_value(RiakObject);
          {error, notfound} ->
              notfound
      end.
  
  %% CS Utilities
  
negative.code:                m_attr(content_length, M), FirstBlockStatus]).
      
  -spec print_object(pid(), string(), string()) -> any().
  print_object(RiakcPid, Bucket, "key=" ++ Key)->
      Manifests = get_manifest(RiakcPid, Bucket, Key),
      io:format("----- ~B instance(s) -----~n", [length(Manifests)]),
      [ print_manifest(Manifest) || Manifest <- Manifests].
  
  show_bucket(RiakcPid, Bucket) ->
      [print_cs_bucket(Bucket, SiblingNo, UserKey, RiakMD)
       || {SiblingNo, {RiakMD, UserKey}}
              <- get_riak_object(RiakcPid, "moss.buckets", Bucket)].
  
  -spec show_manifest(pid(), string(), string()) -> any().
  show_manifest(_RiakcPid, undefined, _Key) ->
      usage(object, show),
      halt(1);
  show_manifest(_RiakcPid, _Bucket, undefined) ->
      usage(object, show),
      halt(1);
  show_manifest(RiakcPid, Bucket, Key) ->
      Manifests = get_manifest(RiakcPid, Bucket, Key),
      io:format("----- ~B instance(s) -----~n", [length(Manifests)]),
      [ print_manifest(Manifest) || Manifest <- Manifests].
  
  -spec count_manifest(pid(), string()) -> any().
  count_manifest(_RiakcPid, undefined) ->
      usage(object, count),
      halt(1);
  count_manifest(RiakcPid, Bucket) ->
      ManifestBucketBin = riak_cs_utils:to_bucket_name(objects, Bucket),
      count_riak_bucket(RiakcPid, ManifestBucketBin, Bucket ++ ":manifests", 100*1000).
  
  stats_sample_from_binary(Bin) ->
      {struct, Sample} = mochijson2:decode(binary_to_list(Bin)),
  