anchor.diff:      % keys mapped to our interval
       DBList = [encodeBlob(KeyX, VersionX) || {KeyX, VersionX} <- DBList0],
       MySyncI = case RMethod of
  -                  merkle_tree -> SyncStruct#merkle_params.interval;
  +                  merkle_tree -> case merkle_tree:is_merkle_tree(SyncStruct) of
  +                                     false -> SyncStruct#merkle_params.interval;
  +                                     true  -> merkle_tree:get_interval(SyncStruct)
  +                                 end;
                     art         -> art:get_interval(SyncStruct)
                 end,
       build_struct(DBList, MySyncI, RestI, State);
  
positive.code:     ?ASSERT(not intervals:is_empty(MySyncI)),
      
      DhtNodePid = State#rr_recon_state.dhtNodePid,
      Self = comm:reply_as(self(), 2, {reconcile, '_'}),
      send_local(DhtNodePid,
                 {get_chunk, Self, MySyncI, fun get_chunk_filter/1,
                  fun get_chunk_value/1, get_max_items(RMethod)}),
      State#rr_recon_state{stage = reconciliation, struct = SyncStruct,
                           method = RMethod, initiator = true,
                           dest_recon_pid = DestReconPid};
  
negative.code: build_struct(DBList, DestI, RestI,
               State = #rr_recon_state{method = RMethod, struct = Params,
                                       initiator = Initiator, stats = Stats,
                                       dhtNodePid = DhtNodePid, stage = Stage}) ->
      {BuildTime, SyncStruct} =
          case merkle_tree:is_merkle_tree(Params) of
              true ->
  