anchor.diff:      Header1 = lists:foldl(Fun1, [], CellColumns),
   
       Fun2 = fun(Col, Str) ->
  -                   {Name, Len} = Col,
  +                   {Name, _} = Col,
                      case Col of
                          {'$end',_Len      } -> lists:append([Str, ?CRLF]);
  -                       {"node", Len      } -> lists:append([Str, string:centre(Name, Len, $ ), ?SEPARATOR]);
                          {"updated at", Len} -> lists:append([Str, string:centre(Name, Len, $ )]);
                          {_Other, Len      } -> lists:append([Str, string:centre(Name, Len, $ ), ?SEPARATOR])
                      end
  
positive.code:                    {"# of chunks",  14},
                     {"clock",        14},
                     {"when",         28},
                     {"END",           0}],
  
      LenPerCol = lists:map(fun({_, Len})-> Len end, CellColumns),
      Fun1 = fun(Col, {Type,Str}) ->
                     {Name, Len} = Col,
                     case Name of
                         "END" when Type =:= title -> {Type, Str ++ ?CRLF};
                         _ when Type =:= title andalso
                                Name =:= "node"-> {Type, " " ++ Str ++ string:left(Name, Len, $ )};
                         _ when Type =:= title -> {Type,        Str ++ string:left(Name, Len, $ )}
                     end
             end,
      {_, Header2} = lists:foldl(Fun1, {title,[]}, CellColumns),
      Sepalator = lists:foldl(
                    fun(N, L) -> L ++ N  end,
                    [], lists:duplicate(lists:sum(LenPerCol), "-")) ++ ?CRLF,
  
      Fun2 = fun(N, List) ->
                     Ret = case N of
                               {Node, not_found} ->
                                   lists:append([" ",
                                                 string:left("", lists:nth(1,LenPerCol)),
                                                 Node,
                                                 ?CRLF]);
                               {Node, VNodeId, DSize, ChunkedObjs, Clock, Timestamp, Checksum, DelFlag} ->
                                   FormattedDate = leo_date:date_format(Timestamp),
                                   DelStr = case DelFlag of
                                                0 -> " ";
                                                _ -> "*"
                                            end,
                                   lists:append([" ",
                                                 string:left(DelStr,                              lists:nth(1,LenPerCol)),
                                                 string:left(Node,                                lists:nth(2,LenPerCol)),
                                                 string:left(leo_hex:integer_to_hex(VNodeId, 8),  lists:nth(3,LenPerCol)),
                                                 string:left(leo_file:dsize(DSize),               lists:nth(4,LenPerCol)),
                                                 string:left(string:sub_string(leo_hex:integer_to_hex(Checksum, 8), 1, 10),
                                                             lists:nth(5,LenPerCol)),
                                                 string:left(integer_to_list(ChunkedObjs),        lists:nth(6,LenPerCol)),
                                                 string:left(leo_hex:integer_to_hex(Clock, 8),    lists:nth(7,LenPerCol)),
                                                 FormattedDate,
                                                 ?CRLF])
                           end,
                     List ++ [Ret]
             end,
      _FormattedList =
          lists:foldl(Fun2, [Sepalator, Header2, Sepalator], AssignedInfo) ++ ?CRLF.
  
  
  %% @doc Format a history list
  
negative.code:                                       false -> Acc
                                    end
                            end, 0, AssignedInfo) + 5,
      CellColumns = [{"del?",          6},
                     {"node",    Col2Len},
                     {"ring address", 36},
                     {"size",         10},
  