}

	dir, err := ioutil.TempDir("", "issue16037-")
	if err != nil {
		log.Fatal(err)
	}
	defer os.RemoveAll(dir)
	path := filepath.Join(dir, "ridiculous_number_of_fields.go")
	if err := ioutil.WriteFile(path, buf.Bytes(), 0664); err != nil {
		log.Fatal(err)
	}

	out, err := exec.Command("go", "build", "-o="+filepath.Join(dir, "out"), path).CombinedOutput()
	if err != nil {
		log.Fatalf("build failed: %v\n%s", err, out)

	var buf bytes.Buffer
	fmt.Fprintln(&buf, `
package main

func main() {
}
`)
	fmt.Fprintln(&buf, "//go:nowritebarrier\r")
	fmt.Fprintln(&buf, `
func x() {
}
`)

	if err := ioutil.WriteFile(filepath.Join(dir, "x.go"), buf.Bytes(), 0666); err != nil {
		log.Fatal(err)
	}

	cmd := exec.Command("go", "tool", "compile", "-p=p", "x.go")
	cmd.Dir = dir
	output, err := cmd.CombinedOutput()
	if err == nil {

	}
	fmt.Fprintf(&buf, fnlast, count)

	dir, err := ioutil.TempDir("", "issue33555")
	if err != nil {
		return err
	}
	defer os.RemoveAll(dir)

	fn := filepath.Join(dir, "x.go")
	if err := ioutil.WriteFile(fn, buf.Bytes(), 0644); err != nil {
		return err
	}

	out, err := exec.Command("go", "run", fn).CombinedOutput()
	if err != nil {
		return err
	}

	want := strconv.Itoa(count + 1)

import org.gradle.internal.snapshot.ValueSnapshot
import org.gradle.kotlin.dsl.*
import org.gradle.kotlin.dsl.cache.KotlinDslWorkspaceProvider
import org.gradle.kotlin.dsl.concurrent.IO
import org.gradle.kotlin.dsl.concurrent.writeFile
import org.gradle.kotlin.dsl.support.bytecode.InternalName
import org.gradle.kotlin.dsl.support.bytecode.newClassTypeOf
import java.io.File
import javax.inject.Inject


/**

		t.Fatalf("succeed to start tracing second time")
	}
	Stop()
	Stop()
}

func saveTrace(t *testing.T, buf *bytes.Buffer, name string) {
	if !*saveTraces {
		return
	}
	if err := os.WriteFile(name+".trace", buf.Bytes(), 0600); err != nil {
		t.Errorf("failed to write trace file: %s", err)
	}

	// we compare the file created by "go build" against a file written explicitly
	// by os.WriteFile.
	//
	// (See https://go.dev/issue/62724, https://go.dev/issue/17909.)
	control := tg.path("control")
	tg.creatingTemp(control)
	if err := os.WriteFile(control, []byte("#!/bin/sh\nexit 0"), 0777); err != nil {
		t.Fatal(err)
	}
	cfi, err := os.Stat(control)
	if err != nil {
		t.Fatal(err)

		panic(err)
	}
	defer os.RemoveAll(dir)

	args := []string{"go", "build"}
	write := func(prefix string, i int, data string) {
		filename := filepath.Join(dir, fmt.Sprintf("%s%d.go", prefix, i))
		if err := os.WriteFile(filename, []byte(data), 0o644); err != nil {
			panic(err)
		}
		args = append(args, filename)
	}

	for i := 0; i < 100; i++ {
		write("a", i, `package p
`)
	}
	for i := 0; i < 100; i++ {

import java.io.Closeable;
import java.io.File;

public interface FileLock extends Closeable, FileAccess {
    /**
     * Returns true if the most recent mutation method ({@link #updateFile(Runnable)} or {@link #writeFile(Runnable)} attempted by any process succeeded
     * (ie a process did not crash while updating the target file).
     *
     * Returns false if no mutation method has ever been called for the target file.
     */

// present in the coverage report from F.
func genAuxMeta(t *testing.T, dstdir string) (string, string) {
	// Do a GOCOVERDIR=<tmp> go run hello.go
	src := filepath.Join(dstdir, "hello.go")
	if err := os.WriteFile(src, []byte(hellogo), 0777); err != nil {
		t.Fatalf("write failed: %v", err)
	}
	args := []string{"run", "-covermode=" + testing.CoverMode(), src}
	cmd := exec.Command(testenv.GoToolPath(t), args...)

    @Suppress("unused")
    @TaskAction
    fun run() {
        outputDir.get().asFile.apply {
            recreate()
            writeFiles()
        }
    }

    protected
    fun File.writeFile(relativePath: String, text: String) {
        resolve(relativePath).apply {
            parentFile.mkdirs()
            writeText(text)
        }
    }

    private
    fun File.recreate() {