// useVFPv1 tries to execute one VFPv1 instruction on ARM.
// It will crash the current process if VFPv1 is missing.
func useVFPv1()

// useVFPv3 tries to execute one VFPv3 instruction on ARM.
// It will crash the current process if VFPv3 is missing.
func useVFPv3()

// useARMv6K tries to run ARMv6K instructions on ARM.
// It will crash the current process if it doesn't implement
// ARMv6K or above.

			// Process a complete line from b.
			line = b[:nl+1]
		}
		b = b[nl+1:]
		f.process(line)
		f.lineBuf.Reset()
	}

	return bn, nil
}

func (f *testJSONFilter) Flush() {
	// Write any remaining partial line to the underlying writer.
	if f.lineBuf.Len() > 0 {
		f.w.Write(f.lineBuf.Bytes())
		f.lineBuf.Reset()
	}
}

func (f *testJSONFilter) process(line []byte) {
	if len(line) > 0 && line[0] == '{' {

	if v, ok := node(); ok {
		return "Node.js " + v, nil
	}
	return "", fmt.Errorf("unrecognized environment")
}

func node() (version string, ok bool) {
	// Try the https://nodejs.org/api/process.html#processversion API.
	p := js.Global().Get("process")
	if p.IsUndefined() {
		return "", false
	}
	v := p.Get("version")
	if v.IsUndefined() {
		return "", false
	}
	return v.String(), true

	PT_REGHSET              = 22 // Read all GPRHs
	PT_ATTACH               = 30 // Attach to a process
	PT_DETACH               = 31 // Detach from a process
	PT_REGSET               = 32 // Read all GPRs
	PT_REATTACH             = 33 // Reattach to a process
	PT_LDINFO               = 34 // Read loader info
	PT_MULTI                = 35 // Multi process mode
	PT_LD64INFO             = 36 // RMODE64 Info Area

	// strange: on Linux, Read returns EIO, and on at least some versions of
	// macOS, unread output may be discarded (see https://go.dev/issue/57141).
	//
	// To avoid that situation, we keep the child process running until the
	// parent has finished reading from the PTY, at which point we unblock the
	// child by closing its stdin pipe.
	stdin, err := cmd.StdinPipe()
	if err != nil {
		t.Fatal(err)
	}

// mmapLimit is the maximum number of mmaped regions to create before
// falling back to reading into a heap-allocated slice. This exists
// because some operating systems place a limit on the number of
// distinct mapped regions per process. As of this writing:
//
//	Darwin    unlimited
//	DragonFly   1000000 (vm.max_proc_mmap)
//	FreeBSD   unlimited
//	Linux         65530 (vm.max_map_count) // TODO: query /proc/sys/vm/max_map_count?
//	NetBSD    unlimited

package pgo

import (
	"bufio"
	"fmt"
	"io"
)

// Serialization of a Profile allows go tool preprofile to construct the edge
// map only once (rather than once per compile process). The compiler processes
// then parse the pre-processed data directly from the serialized format.
//
// The format of the serialized output is as follows.
//
//      GO PREPROFILE V1
//      caller_name

	// returned when “the lock is blocked by a lock from another process”.
	// If that process is blocked on some lock that we are holding, then the
	// resulting livelock is due to a real deadlock (and would manifest as such
	// when using, for example, the flock implementation of this package).
	// If the other process is *not* blocked on some other lock that we are

		if err := syscall.Exec(os.Args[0], argv, os.Environ()); err != nil {
			t.Fatal(err)
		}
	}

	var cmds []*exec.Cmd
	defer func() {
		for _, cmd := range cmds {
			cmd.Process.Kill()
		}
	}()

	args := append(append([]string(nil), os.Args[1:]...), "-test.run=^Test18146$")
	for n := attempts; n > 0; n-- {
		cmd := exec.Command(os.Args[0], args...)

		}
		needProgress, lastFull = lastFull, false
		switch err0 {
		case ErrShortDst:
			// Process the destination buffer next. Return if we are already
			// at the high index.
			if i == high {
				return dstL.n, srcL.p, ErrShortDst
			}
			if out.n != 0 {
				i++
				// If the Transformer at the next index is not able to process any
				// source bytes there is nothing that can be done to make progress