runtime.ReadMemStats(&m.curMark.endM)
	if m.gc == GC {
		runtime.GC()
		runtime.ReadMemStats(&m.curMark.gcM)
		if m.shouldPProf() {
			// Collect a profile of the live heap. Do a
			// second GC to force sweep completion so we
			// get a complete snapshot of the live heap at
			// the end of this phase.
			runtime.GC()
			f, err := os.Create(makePProfFilename(m.filebase, m.curMark.name, "memprof"))
			if err != nil {

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

/**
 * Test that ArtifactView has a "live" view of the underlying configuration's attributes.
 */
class ArtifactViewAttributesIntegrationTest extends AbstractIntegrationSpec {
    def "artifact view has live view of underlying configuration attributes"() {
        buildFile << """
            def usage = Attribute.of('usage', String)

            '''
                /**
                 * A person.
                 * Can live in a house.
                 * Has a name and an age.
                 */
                class Person(val name: String, val age: Int)'''.stripIndent(),
            '''
                /**
                 * A person.
                 * Can live in a house.
                 * Has a name, age and a height.
                 */

	badPtr = uintptr(unsafe.Pointer(&b[len(b)-1])) + 1
}

var throttle = make(chan struct{}, 10)

// There are 2 arg bitmaps for this function, each with 2 bits.
// In the first, p and q are both live, so that bitmap is 11.
// In the second, only p is live, so that bitmap is 10.
// Bitmaps are byte aligned, so if the first bitmap is interpreted as
// extending across the entire argument area, we incorrectly concatenate

//   - It sets IsCA to false.
//   - It validates that the signer has not expired.
//   - It sets NotBefore and NotAfter:
//     All certificates set NotBefore = Now() - Backdate.
//     Long-lived certificates set NotAfter = Now() + TTL - Backdate.
//     Short-lived certificates set NotAfter = Now() + TTL.
//     All certificates truncate NotAfter to the expiration date of the signer.
type PermissiveSigningPolicy struct {

	// Output:
	// Good morning, Gopher!
}

func ExampleExpandEnv() {
	os.Setenv("NAME", "gopher")
	os.Setenv("BURROW", "/usr/gopher")

	fmt.Println(os.ExpandEnv("$NAME lives in ${BURROW}."))

	// Output:
	// gopher lives in /usr/gopher.
}

func ExampleLookupEnv() {
	show := func(key string) {
		val, ok := os.LookupEnv(key)
		if !ok {
			fmt.Printf("%s not set\n", key)
		} else {

	p1.x[i] = j
	r += p1.x[j]
	p2.x[i] = j
	r += p2.x[j]
	if j != 505 {
		var xp3 Pointery2
		xp3.x[i] = j
		r += xp3.x[j]
	}

	if i == j*2 {
		// p2 live on this path
		p2.x[i] += j
		r += p2.x[j]
	} else {
		// p2 not live on this path
		var xp4 Pointery2
		xp4.x[i] = j
		r += xp4.x[j]
	}

	return r + G

     */
    PipedOutputStream getStdinPipe();

    /**
     * Returns the stdout output currently received from the build. This is live.
     */
    String getStandardOutput();

    /**
     * Returns the stderr output currently received from the build. This is live.
     */
    String getErrorOutput();

    /**
     * Forcefully kills the build and returns immediately. Does not block until the build has finished.

//go:registerparams
//go:noinline
func f(x int, xm1, xm2, p *int) {
	var y = [2]int{x - 4, 0}
	if x < 2 {
		*p += x
		return
	}
	x -= 3
	g(*xm1, xm2, &x, p)   // xm1 is no longer live.
	h(*xm2, &x, &y[0], p) // xm2 is no longer live, but was spilled.
}

//go:registerparams
//go:noinline
func g(x int, xm1, xm2, p *int) {
	var y = [3]int{x - 4, 0, 0}
	if x < 2 {
		*p += x
		return
	}
	x -= 3

// The liveness code used to say that, in func g, s was live
// starting at its declaration, because it appears to have its
// address taken by the closure (different s, but the parser
// gets slightly confused, a separate bug). The liveness analysis
// saw s as having its address taken but the register optimizer
// did not. This mismatch meant that s would be marked live
// (and therefore initialized) at the call to f, but the register optimizer