panic(fmt.Sprintf("cannot merge into invalid %v message", dst.Descriptor().FullName()))
	}

	src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
		switch {
		case fd.IsList():
			o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
		case fd.IsMap():
			o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
		case fd.Message() != nil:
			mergeFn, exists := o.customMergeFn[fd.Message().FullName()]

	specList := make([]cached.Value[*spec.Swagger], 0, len(c.specsByName))
	for crd := range c.specsByName {
		specList = append(specList, c.specsByName[crd].mergedVersionSpec)
	}

	cache := cached.MergeList(func(results []cached.Result[*spec.Swagger]) (*spec.Swagger, string, error) {
		localCRDSpec := make([]*spec.Swagger, 0, len(results))
		for k := range results {
			if results[k].Err == nil {

                    mergedItem = SuggestItem.merge(mergedItem, item2);
                    mergedIdSet.add(item1Id);
                }
            }
            mergedList.add(mergedItem);
        }

        return mergedList.toArray(new SuggestItem[mergedList.size()]);
    }

//
// The merging is performed by a combination of the multiplication
// merge rules
//  (c*n + d*n) -> (c+d)*n
// and the distributive multiplication rules
//  c * (d+x)  ->  c*d + c*x

// Generate a MergeTest that looks like this:
//
//   a8, b8 = m1*n8 + m2*(n8+k), (m1+m2)*n8 + m2*k
//   if a8 != b8 {
// 	   // print error msg and panic
//   }
func makeMergeAddTest(m1, m2, k int, size string) string {

    private final Object2IntMap<InstrumentableClosure> currentClosuresEntries = new Object2IntOpenHashMap<>();

    @Override
    public void enterClosure(InstrumentableClosure thisClosure) {
        currentClosuresEntries.mergeInt(thisClosure, 1, Integer::sum);
    }

    @Override
    public void leaveClosure(InstrumentableClosure thisClosure) {
        currentClosuresEntries.computeInt(thisClosure, (key, oldValue) -> {

	//   3. current.NUMANodeAffinity.Count() <  bestNonPreferredAffinityCount
	//
	// For case (1), the current bestHint is larger than the
	// bestNonPreferredAffinityCount, so updating to fitter mergeHint
	// is preferred over staying where we are.
	//
	// For case (2), the current bestHint is equal to the
	// bestNonPreferredAffinityCount, so we would like to stick with what