SuggestItem mergedItem = item1;
            for (final SuggestItem item2 : items) {
                if (item1.equals(item2)) {
                    continue;
                }

                final String item2Id = item2.getId();
                if (item1Id.equals(item2Id)) {
                    mergedItem = SuggestItem.merge(mergedItem, item2);
                    mergedIdSet.add(item1Id);
                }
            }

		cgran         coverage.CounterGranularity
		src, dst, res []uint32
		iters         int
		merr          bool
		overflow      bool
	}{
		{
			cmode:    coverage.CtrModeSet,
			cgran:    coverage.CtrGranularityPerBlock,
			src:      []uint32{1, 0, 1},
			dst:      []uint32{1, 1, 0},
			res:      []uint32{1, 1, 1},
			iters:    2,
			overflow: false,
		},
		{
			cmode:    coverage.CtrModeCount,

    return item


def dependency(item2: Item):
    return item2


def sub_duplicate_dependency(
    item: Item, sub_item: Item = Depends(duplicate_dependency)
):
    return [item, sub_item]


@app.post("/with-duplicates")
async def with_duplicates(item: Item, item2: Item = Depends(duplicate_dependency)):
    return [item, item2]


@app.post("/no-duplicates")

pkg maps, func Collect[$0 comparable, $1 interface{}](iter.Seq2[$0, $1]) map[$0]$1 #61900
pkg maps, func Insert[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, iter.Seq2[$1, $2]) #61900
pkg maps, func Keys[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$1] #61900
pkg maps, func Values[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$2] #61900

	if elem == nil {
		return nil, nil
	}
	return iterToValue(elem.Iter)
}

func iterToValue(iter simdjson.Iter) (*sql.Value, error) {
	switch iter.Type() {
	case simdjson.TypeString:
		v, err := iter.String()
		if err != nil {
			return nil, err
		}
		return sql.FromString(v), nil
	case simdjson.TypeFloat:
		v, err := iter.Float()
		if err != nil {
			return nil, err
		}
		return sql.FromFloat(v), nil

		panic("missing a.init")
	}

	// Check the CallersFrames results.
	if debug {
		iter := runtime.CallersFrames(pcs[:n])
		for {
			f, more := iter.Next()
			fmt.Printf("%s %s:%d\n", f.Function, f.File, f.Line)
			if !more {
				break
			}
		}
	}
	iter := runtime.CallersFrames(pcs[:n])
	f, more := iter.Next()
	if f.Function != "test/a.f" || !strings.HasSuffix(f.File, "a.go") || f.Line != 22 {

	"testing"
)

func TestReproducibleBuilds(t *testing.T) {
	tests := []string{
		"issue20272.go",
		"issue27013.go",
		"issue30202.go",
	}

	testenv.MustHaveGoBuild(t)
	iters := 10
	if testing.Short() {
		iters = 4
	}
	t.Parallel()
	for _, test := range tests {
		test := test
		t.Run(test, func(t *testing.T) {
			t.Parallel()
			var want []byte
			tmp, err := os.CreateTemp("", "")

		// Passed on first try, report no error.
		return nil
	}
	allocInterleaved2(iters)
	if checkAllocations(getMemProfileRecords(), frames[0:2], iters, allocInterleavedSizes) == nil {
		// Passed on second try, report no error.
		return nil
	}
	allocInterleaved3(iters)
	// If it fails a third time, we may be onto something.
	return checkAllocations(getMemProfileRecords(), frames[0:3], iters, allocInterleavedSizes)

				nil,
				true,
				gvk,
				schemaValidator,
				nil,
				sts,
				nil,
				nil,
				nil,
			)

			iters := 1
			if tt.iters > 0 {
				iters = tt.iters
			}
			for i := 0; i < iters; i++ {
				_ = strategy.ValidateUpdate(context.TODO(), tt.obj, tt.old)
			}

	}

	item2 := InterfaceItem{}
	err = NewDecoder(b).Decode(&item2)
	if err != nil {
		t.Fatal("decode:", err)
	}
	if item2.I != item1.I {
		t.Error("normal int did not decode correctly")
	}
	if item2.Sq1 == nil || item2.Sq1.Square() != iVal.Square() {
		t.Error("Int did not decode correctly")
	}
	if item2.Sq2 == nil || item2.Sq2.Square() != fVal.Square() {