anchor.diff:  
   %% @doc Compare local-checksum with remote-checksum
   %% @private
  -compare_local_chksum_with_remote_chksum(_Type,_Node, Checksum_0, Checksum_1) when Checksum_0 =:= Checksum_1 ->
  +compare_local_chksum_with_remote_chksum(_,_, Checksum_1, Checksum_2)
  +  when Checksum_1 =:= Checksum_2 -> ok;
  +compare_local_chksum_with_remote_chksum(Type, Node, Checksum_1, Checksum_2)
  +  when Checksum_1 =/= Checksum_2 -> synchronize_1(Type, Node).
  +
  +%% @private
  +compare_local_chksum_with_remote_chksum(_,_,RemoteChecksum,_,RemoteChecksum) ->
       ok;
  -compare_local_chksum_with_remote_chksum( Type, Node, Checksum_0, Checksum_1) when Checksum_0 =/= Checksum_1 ->
  -    synchronize_1(Type, Node).
  -
  -compare_local_chksum_with_remote_chksum(_Type,_Node, Checksum_0, Checksum_1, RemoteChecksum)
  -  when Checksum_0 =:= RemoteChecksum orelse
  -       Checksum_1 =:= RemoteChecksum ->
  +compare_local_chksum_with_remote_chksum(_,_,_,RemoteChecksum,RemoteChecksum) ->
       ok;
  -compare_local_chksum_with_remote_chksum( Type, Node,_Checksum_0,_Checksum_1,_RemoteChecksum) ->
  +compare_local_chksum_with_remote_chksum(Type, Node,_,_,_) ->
       synchronize_1(Type, Node).
   
   
  
positive.code:         undefined ->
              {error, not_found};
          _ ->
              case rpc:call(Node_1, Mod, get_node_status, [], ?DEF_TIMEOUT) of
                  {ok, Status} ->
                      {ok, {Type, Status}};
                  {_, Cause} ->
  
negative.code: %% @private
  distribute_members([]) ->
      ok;
  distribute_members([_|_]= Nodes) ->
      %% Retrieve storage-nodes from mnesia
      case leo_redundant_manager_api:get_members() of
          {ok, Members} ->
              StorageNodes = lists:filter(
                               fun(N) ->
                                       lists:member(N, Nodes) /= true
                               end,  [_N || #member{node  = _N,
                                                    state = ?STATE_RUNNING} <- Members]),
  
              %% Retrieve gateway nodes, then merge them with storage-nodes
              %% they're destination nodes in order to update "members"
              DestNodes = case leo_manager_mnesia:get_gateway_nodes_all() of
                              {ok, List} ->
                                  lists:merge(StorageNodes,
                                              [_N || #member{node  = _N,
                                                             state = ?STATE_RUNNING} <- List]);
                              _ ->
                                  StorageNodes
                          end,
  
              case rpc:multicall(DestNodes, leo_redundant_manager_api, update_members,
                                 [Members], ?DEF_TIMEOUT) of
                  {_, []} ->
                      void;
                  {_, BadNodes} ->
                      ?error("distribute_members/2", "bad-nodes:~p", [BadNodes])
              end,
              ok;
          Error ->
              Error
      end;
  
  distribute_members(Node) when is_atom(Node) ->
      distribute_members(ok, Node).
  
  -spec(distribute_members(ok, atom()) ->
               ok | {error, any()}).
  distribute_members(ok, Node) ->
      distribute_members([Node]);
  distribute_members(Error, _Node) ->
      Error.
  
  