pkg syscall (netbsd-386), const ETHERTYPE_DECMUMPS = 24585
pkg syscall (netbsd-386), const ETHERTYPE_DECNETBIOS = 32832
pkg syscall (netbsd-386), const ETHERTYPE_DELTACON = 34526
pkg syscall (netbsd-386), const ETHERTYPE_DIDDLE = 17185
pkg syscall (netbsd-386), const ETHERTYPE_DLOG1 = 1632
pkg syscall (netbsd-386), const ETHERTYPE_DLOG2 = 1633
pkg syscall (netbsd-386), const ETHERTYPE_DN = 24579

pkg net, type KeepAliveConfig struct #62254
pkg net, type KeepAliveConfig struct, Count int #62254
pkg net, type KeepAliveConfig struct, Enable bool #62254
pkg net, type KeepAliveConfig struct, Idle time.Duration #62254
pkg net, type KeepAliveConfig struct, Interval time.Duration #62254
pkg net, type ListenConfig struct, KeepAliveConfig KeepAliveConfig #62254
pkg syscall (windows-386), const WSAENOPROTOOPT = 10042 #62254

<code>fmt.Printf</code> or <code>math/rand.Int</code>.
Because the assembler's parser treats period and slash as punctuation,
those strings cannot be used directly as identifier names.
Instead, the assembler allows the middle dot character U+00B7
and the division slash U+2215 in identifiers and rewrites them to
plain period and slash.
Within an assembler source file, the symbols above are written as

		}
	}
}

func TestLastIndexByte(t *testing.T) {
	testCases := []BinOpTest{
		{"", "q", -1},
		{"abcdef", "q", -1},
		{"abcdefabcdef", "a", len("abcdef")},      // something in the middle
		{"abcdefabcdef", "f", len("abcdefabcde")}, // last byte
		{"zabcdefabcdef", "z", 0},                 // first byte
		{"a☺b☻c☹d", "b", len("a☺")},               // non-ascii
	}
	for _, test := range testCases {

				},
				gojs: {
					// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
					// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
					// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
					// This changes the SP, thus we have to update the SP used by the imported function.

pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_DELTACON = 34526
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_DELTACON ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_DIDDLE = 17185
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_DIDDLE ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_DLOG1 = 1632
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_DLOG1 ideal-int

func isIdentRune(ch rune, i int) bool {
	if unicode.IsLetter(ch) {
		return true
	}
	switch ch {
	case '_': // Underscore; traditional.
		return true
	case '\u00B7': // Represents the period in runtime.exit. U+00B7 '·' middle dot
		return true
	case '\u2215': // Represents the slash in runtime/debug.setGCPercent. U+2215 '∕' division slash
		return true
	}
	// Digits are OK only after the first character.
	return i > 0 && unicode.IsDigit(ch)

pkg syscall (linux-386), const SYS_GET_ROBUST_LIST ideal-int
pkg syscall (linux-386), const SYS_GET_THREAD_AREA ideal-int
pkg syscall (linux-386), const SYS_GTTY ideal-int
pkg syscall (linux-386), const SYS_IDLE ideal-int
pkg syscall (linux-386), const SYS_INIT_MODULE ideal-int
pkg syscall (linux-386), const SYS_INOTIFY_ADD_WATCH ideal-int
pkg syscall (linux-386), const SYS_INOTIFY_INIT ideal-int

	"testing"
)

func TestExitCodeFilter(t *testing.T) {
	// Write text to the filter one character at a time.
	var out strings.Builder
	f, exitStr := newExitCodeFilter(&out)
	// Embed a "fake" exit code in the middle to check that we don't get caught on it.
	pre := "abc" + exitStr + "123def"
	text := pre + exitStr + `1`
	for i := 0; i < len(text); i++ {
		_, err := f.Write([]byte{text[i]})
		if err != nil {
			t.Fatal(err)
		}

	}
	return true
}

// It would be nice if the error messages always began with
// the standard file:line: prefix,
// but that's not where we are today.
// It might be at the beginning but it might be in the middle of the printed instruction.
var fileLineRE = regexp.MustCompile(`(?:^|\()(testdata[/\\][\da-z]+\.s:\d+)(?:$|\)|:)`)

// Same as in test/run.go
var (
	errRE       = regexp.MustCompile(`// ERROR ?(.*)`)