{"PNG image", []byte("\x89PNG\x0D\x0A\x1A\x0A"), "image/png"},
	{"JPEG image", []byte("\xFF\xD8\xFF"), "image/jpeg"},

	// Audio types.
	{"MIDI audio", []byte("MThd\x00\x00\x00\x06\x00\x01"), "audio/midi"},
	{"MP3 audio/MPEG audio", []byte("ID3\x03\x00\x00\x00\x00\x0f"), "audio/mpeg"},
	{"WAV audio #1", []byte("RIFFb\xb8\x00\x00WAVEfmt \x12\x00\x00\x00\x06"), "audio/wave"},

package os

import (
	"syscall"
	"unsafe"
)

const _P_PID = 0

func wait6(idtype, id, options int) (status int, errno syscall.Errno) {
	// freebsd32_wait6_args{ idtype, pad, id1, id2, status, options, wrusage, info }
	_, _, errno = syscall.Syscall9(syscall.SYS_WAIT6, uintptr(idtype), 0, uintptr(id), 0, uintptr(unsafe.Pointer(&status)), uintptr(options), 0, 0, 0)
	return status, errno

    /**
     * @return status code
     */
    int getErrorCode ();


    /**
     * @param k
     */
    void setMid ( long k );


    /**
     * @return mid
     */
    long getMid ();


    /**
     * 
     * @param buffer
     * @param i
     * @param size
     * @return whether signature verification is successful
     */

[short] skip 'generates a vcstest git repo'
[!git] skip

mkdir $WORK/mod1
mkdir $WORK/mod2
env GONOSUMDB=vcs-test.golang.org

env GOPROXY=direct
env GOMODCACHE=$WORK/mod1


# If we query a module version from a git repo, we expect its
# Origin data to be reusable.

go list -m -json vcs-test.golang.org/git/issue61415.git@latest
cp stdout git-latest.json
stdout '"Version": "v0.0.0-20231114180001-f213069baa68"'
stdout '"Origin":'

}
"""
        }
    }

    void prepareComponentNotFound() {
        def resolveAndCheck = """
        def mid = org.gradle.api.internal.artifacts.DefaultModuleIdentifier.newId("${id.group}", "${id.module}")
        def componentId = new org.gradle.internal.component.external.model.DefaultModuleComponentIdentifier(mid, "${id.version}")

        def result = dependencies.createArtifactResolutionQuery()
            .forComponents(componentId)

	for i := 0; i < procs; i++ {
		i := i
		go func() {
			for {
				sink[i] = make([]byte, 4<<10)
			}
		}()
	}
	// Increase the chance that we end up starting and stopping
	// mid-GC by only starting to trace after a few milliseconds.
	time.Sleep(5 * time.Millisecond)

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}

    <snapshotRepository>
      <id>repo-id</id>
      <name>my snapshot repository</name>
      <url>file:///path/to/snapshot/repo</url>
    </snapshotRepository>
    <repository>
      <id>repo-id2</id>
      <name>my repository</name>
      <url>file:///path/to/repo</url>
    </repository>
  </distributionManagement>

	fmt.Fprintf(w, "package main\n")
	fmt.Fprintf(w, "import \"testing\"\n")

	for _, s := range sizes {
		// type for test
		fmt.Fprintf(w, "type Z%d struct {\n", s)
		fmt.Fprintf(w, "  pre [8]byte\n")
		fmt.Fprintf(w, "  mid [%d]byte\n", s)
		fmt.Fprintf(w, "  post [8]byte\n")
		fmt.Fprintf(w, "}\n")

		// function being tested
		fmt.Fprintf(w, "//go:noinline\n")
		fmt.Fprintf(w, "func zero%d_ssa(x *[%d]byte) {\n", s, s)

  auto id =
      StringAttr::get(&context, "//tensorflow/python/keras/keras_file.py");
  auto loc = FileLineColLoc::get(&context, id, 0, 0);
  auto id2 =
      StringAttr::get(&context, "//tensorflow/python/something/my_test.py");
  auto loc2 = FileLineColLoc::get(&context, id2, 0, 0);
  auto id3 = StringAttr::get(&context, "python/tensorflow/show_file.py");
  auto loc3 = FileLineColLoc::get(&context, id3, 0, 0);

	params := lwpparams{
		start_func: abi.FuncPCABI0(lwp_start),
		arg:        unsafe.Pointer(mp),
		stack:      uintptr(stk),
		tid1:       nil, // minit will record tid
		tid2:       nil,
	}

	// TODO: Check for error.
	retryOnEAGAIN(func() int32 {
		lwp_create(&params)
		return 0
	})
	sigprocmask(_SIG_SETMASK, &oset, nil)
}

func osinit() {
	ncpu = getncpu()