}
				vMod = append(vMod, newVers)
			}
			merged := mergeXLV2Versions(i, true, 0, vMod...)
			if len(merged) == 0 && i < 2 {
				t.Error("Did not get any results")
				return
			}
			if len(merged) > 0 && i >= 2 {
				t.Error("Got unexpected results", len(merged), merged[0].header)
				return
			}
			for _, ver := range merged {
				if ver.header.Type == invalidVersionType {

                merged.put(key, element);
            }

            for (Repository element : recessive) {
                Object key = getRepositoryKey(element);
                if (!merged.containsKey(key)) {
                    merged.put(key, element);
                }
            }

            target.setRepositories(new ArrayList<>(merged.values()));
        }
    }

            Properties merged = new Properties();
            if (sourceDominant) {
                merged.putAll(target.getProperties());
                putAll(merged, source.getProperties(), CHILD_DIRECTORY_PROPERTY);
            } else {
                putAll(merged, source.getProperties(), CHILD_DIRECTORY_PROPERTY);
                merged.putAll(target.getProperties());
            }

			merged = append(merged, b[0])
			b = b[1:]
		}
		if limit > 0 && len(merged) >= limit {
			break
		}
	}
	// Append anything left.
	if limit < 0 || len(merged) < limit {
		merged = append(merged, a...)
		merged = append(merged, b...)
	}
	m.o = merged
}

// filterPrefix will filter m to only contain entries with the specified prefix.
func (m *metaCacheEntriesSorted) filterPrefix(s string) {

        SuggestItem merged = SuggestItem.merge(item1, item2);

        // Should have all 3 kinds
        assertEquals(3, merged.getKinds().length);
        assertTrue(Arrays.asList(merged.getKinds()).contains(SuggestItem.Kind.QUERY));
        assertTrue(Arrays.asList(merged.getKinds()).contains(SuggestItem.Kind.DOCUMENT));
        assertTrue(Arrays.asList(merged.getKinds()).contains(SuggestItem.Kind.USER));
    }

        SuggestItem merged = SuggestItem.merge(item1, item2);

        assertNotNull(merged);
        assertEquals("item1", merged.getText());
        assertEquals(150L, merged.getQueryFreq()); // Sum of frequencies
        assertEquals(75L, merged.getDocFreq()); // Sum of frequencies
        assertEquals(1.5f, merged.getUserBoost(), 0.001f); // Takes item2's boost

		}

		merged = merged[:0]
		m := message{Op: OpMerged, Seq: uint32(len(queue))}
		var err error
		merged, err = m.MarshalMsg(merged)
		if err != nil {
			gridLogIf(ctx, fmt.Errorf("msg.MarshalMsg: %w", err))
			return
		}
		// Append as byte slices.
		for _, q := range queue {
			merged = msgp.AppendBytes(merged, q)
			PutByteBuffer(q)
		}
		queue = queue[:0]

     * and will be merged, but overlapping ranges will cause an exception when {@link #build()} is
     * called.
     */
    @CanIgnoreReturnValue
    public Builder<C> addAll(RangeSet<C> ranges) {
      return addAll(ranges.asRanges());
    }

    /**
     * Add all of the specified ranges to this builder. Adjacent ranges are permitted and will be

// Merge data of two ReplicationLastHour structure
func (l ReplicationLastHour) merge(o ReplicationLastHour) (merged ReplicationLastHour) {
	if l.LastMin > o.LastMin {
		o.forwardTo(l.LastMin)
		merged.LastMin = l.LastMin
	} else {
		l.forwardTo(o.LastMin)
		merged.LastMin = o.LastMin
	}

	for i := range merged.Totals {
		merged.Totals[i] = AccElem{
			Total: l.Totals[i].Total + o.Totals[i].Total,

     * and will be merged, but overlapping ranges will cause an exception when {@link #build()} is
     * called.
     */
    @CanIgnoreReturnValue
    public Builder<C> addAll(RangeSet<C> ranges) {
      return addAll(ranges.asRanges());
    }

    /**
     * Add all of the specified ranges to this builder. Adjacent ranges are permitted and will be