}
            }

            subprojects {
                tasks.create('slow', SlowTask)
            }
            project(':a') {
                tasks.slow.dependsOn(project(':b').tasks.slow, project(':c').tasks.slow)
            }
        """

        expect:
        2.times {
            server.expectConcurrent("b", "c")

		runtime.GC()
	}()
	// Make x live at the defer's PC.
	runtime.KeepAlive(x)

	// x is no longer live. Garbage collect the [32]*int on the
	// heap.
	runtime.GC()
	// At this point x's dead stack slot points to dead memory.

	// Trigger a sigpanic. Since this is an implicit panic, we
	// don't have an explicit liveness map here.
	// Traceback used to use the liveness map of the most recent defer,

        given:
        file('src/test/java/MyTest.java') << standaloneTestClass
        file("src/test/java/Slow.java") << """public interface Slow {}"""

        settingsFile << "rootProject.name = 'Sample'"
        buildFile << """apply plugin: 'java'
            test {
                options {
                    excludeCategories = ["Slow"]
                }
                $configureTestFramework
            }
        """.stripIndent()

        {
            "detail": [
                {
                    "type": "missing",
                    "loc": ["body", "file"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["body", "fileb"],
                    "msg": "Field required",
                    "input": None,
                },

//	                          parent = &{N: s, Type: string}
type LocalSlot struct {
	N    *ir.Name    // an ONAME *ir.Name representing a stack location.
	Type *types.Type // type of slot
	Off  int64       // offset of slot in N

	SplitOf     *LocalSlot // slot is a decomposition of SplitOf
	SplitOffset int64      // .. at this offset.
}

func (s LocalSlot) String() string {
	if s.Off == 0 {
		return fmt.Sprintf("%v[%v]", s.N, s.Type)

	for i := 0; i < passCount; i++ {
		fn(fun.f)
	}
	b.StopTimer()
}

func genFunction(size int) []bloc {
	var blocs []bloc
	elemType := types.Types[types.TINT64]
	ptrType := elemType.PtrTo()

	valn := func(s string, m, n int) string { return fmt.Sprintf("%s%d-%d", s, m, n) }
	blocs = append(blocs,
		Bloc("entry",
			Valu(valn("store", 0, 4), OpInitMem, types.TypeMem, 0, nil),

	check(err)
	importcfg := string(stdlibimportcfg) + "\npackagefile test/slow=" + tmp("test/slow.o") + "\npackagefile test/fast=" + tmp("test/fast.o")
	os.WriteFile(tmp("importcfg"), []byte(importcfg), 0644)

	run("go", "tool", "compile", "-importcfg="+tmp("importcfg"), "-p=test/slow", "-N", "-o", tmp("test/slow.o"), "pkg.go")

// CHECK-NEXT:   func @main([[ARG0:%.+]]: tensor<?xi32> loc({{.*}})) -> tensor<?xi32> {
// CHECK-NEXT:     [[IDENTITY:%.+]] = "tf.Identity"([[ARG0]]) : (tensor<?xi32>) -> tensor<?xi32> loc(unknown)
// CHECK-NEXT:     return [[IDENTITY]] : tensor<?xi32> loc(unknown)
// CHECK-NEXT:   } loc(unknown)

}

func f(d func(error) error) error {
	// Initialize callee args section with a bad pointer.
	g(badPtr, badPtr, badPtr, badPtr)

	// Then call a function which returns a pointer.
	// That return slot starts out holding a bad pointer.
	return d(io.EOF)
}

//go:noinline
func g(x, y, z, w uintptr) {
}

type T struct {
}

func (t *T) Foo(e error) error {
	runtime.GC()
	return e
}

    for misconfigured server first protocols rather than failing fast.

    This timeout has been disabled by default. This has the following impacts:

    - Non "server first" protocols will no longer have a risk of telemetry or traffic failures during slow connections