anchor.diff:  
   notify2(?STATE_RUNNING = State, Node) ->
       Ret = case rpc:call(Node, ?API_STORAGE, get_routing_table_chksum, [], ?DEF_TIMEOUT) of
  -              {ok, {RingHash0, RingHash1}} ->
  +              {ok, {RingHashCur, RingHashPrev}} ->
                     case rpc:call(Node, ?API_STORAGE, register_in_monitor, [again], ?DEF_TIMEOUT) of
                         ok ->
                             leo_manager_mnesia:update_storage_node_status(
                               update, #node_state{node          = Node,
                                                   state         = State,
  -                                                ring_hash_new = leo_hex:integer_to_hex(RingHash0, 8),
  -                                                ring_hash_old = leo_hex:integer_to_hex(RingHash1, 8),
  +                                                ring_hash_new = leo_hex:integer_to_hex(RingHashCur,  8),
  +                                                ring_hash_old = leo_hex:integer_to_hex(RingHashPrev, 8),
                                                   when_is       = leo_date:now()});
                         {_, Cause} ->
                             {error, Cause}
  
positive.code: notify(launched, gateway, Node, Checksums0) ->
      case get_routing_table_chksum() of
          {ok, Checksums1} when Checksums0 == Checksums1 ->
              {RingHash0, RingHash1} = Checksums1,
              leo_manager_mnesia:update_gateway_node(
                #node_state{node          = Node,
                            state         = ?STATE_RUNNING,
                            ring_hash_new = leo_hex:integer_to_hex(RingHash0, 8),
                            ring_hash_old = leo_hex:integer_to_hex(RingHash1, 8),
                            when_is       = leo_date:now()});
          {ok, _} ->
              {error, ?ERR_TYPE_INCONSISTENT_HASH};
  
negative.code:             Ret
      end;
  
  synchronize(?CHECKSUM_RING = Type, [{Node_1, {RingHashCur_1, RingHashPrev_1}},
                                      {Node_2, {RingHashCur_2, RingHashPrev_2}}]) ->
      case leo_redundant_manager_api:checksum(Type) of
          {ok, {LocalRingHashCur, LocalRingHashPrev}} ->
              %% copare manager-cur-ring-hash with remote cur-ring-hash
              _ = compare_local_chksum_with_remote_chksum(
                    ?SYNC_TARGET_RING_CUR,  Node_1, LocalRingHashCur,  RingHashCur_1),
              _ = compare_local_chksum_with_remote_chksum(
                    ?SYNC_TARGET_RING_CUR,  Node_2, LocalRingHashCur,  RingHashCur_2),
  
              %% copare manager-cur/prev-ring-hash/ with remote prev-ring-hash
              _ = compare_local_chksum_with_remote_chksum(
                    ?SYNC_TARGET_RING_PREV, Node_1, LocalRingHashCur, LocalRingHashPrev, RingHashPrev_1),
              _ = compare_local_chksum_with_remote_chksum(
                    ?SYNC_TARGET_RING_PREV, Node_2, LocalRingHashCur, LocalRingHashPrev, RingHashPrev_2);
          Error ->
              Error
      end.
  