return 0, nil, nil
		}
		// There is one final token to be delivered, which may be the empty string.
		// Returning bufio.ErrFinalToken here tells Scan there are no more tokens after this
		// but does not trigger an error to be returned from Scan itself.
		return 0, data, bufio.ErrFinalToken
	}
	scanner.Split(onComma)
	// Scan.
	for scanner.Scan() {
		fmt.Printf("%q ", scanner.Text())
	}

spaces (U+0020), horizontal tabs (U+0009),
carriage returns (U+000D), and newlines (U+000A),
is ignored except as it separates tokens
that would otherwise combine into a single token. Also, a newline or end of file
may trigger the insertion of a <a href="#Semicolons">semicolon</a>.
While breaking the input into tokens,
the next token is the longest sequence of characters that form a
valid token.
</p>

<h3 id="Semicolons">Semicolons</h3>

pkg syscall (darwin-386), const NOTE_SIGNAL = 134217728
pkg syscall (darwin-386), const NOTE_TRACK = 1
pkg syscall (darwin-386), const NOTE_TRACKERR = 2
pkg syscall (darwin-386), const NOTE_TRIGGER = 16777216
pkg syscall (darwin-386), const NOTE_USECONDS = 2
pkg syscall (darwin-386), const NOTE_VM_ERROR = 268435456
pkg syscall (darwin-386), const NOTE_VM_PRESSURE = 2147483648

				_gotest: {
					add: (a, b) => a + b,
				},
				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).

			continue
		}
		if !strings.Contains(err.Error(), test.error) {
			t.Errorf("got error %q expected %q", err.Error(), test.error)
		}
	}
}

// firstError returns the first error value triggered by the input.
func firstError(input *Input) (err error) {
	panicOnError = true
	defer func() {
		panicOnError = false
		switch e := recover(); e := e.(type) {
		case nil:
		case error:
			err = e

pkg syscall (freebsd-386-cgo), const NOTE_REVOKE ideal-int
pkg syscall (freebsd-386-cgo), const NOTE_TRACK ideal-int
pkg syscall (freebsd-386-cgo), const NOTE_TRACKERR ideal-int
pkg syscall (freebsd-386-cgo), const NOTE_TRIGGER ideal-int
pkg syscall (freebsd-386-cgo), const NOTE_WRITE ideal-int
pkg syscall (freebsd-386-cgo), const OCRNL ideal-int
pkg syscall (freebsd-386-cgo), const ONLCR ideal-int

			{"TrimRightFunc", TrimRightFunc, tc.rightOut},
		}
		for _, trimmer := range trimmers {
			actual := trimmer.trim([]byte(tc.in), tc.f.f)
			if actual == nil && trimmer.out != nil {
				t.Errorf("%s(%q, %q) = nil; want %q", trimmer.name, tc.in, tc.f.name, trimmer.out)
			}
			if actual != nil && trimmer.out == nil {
				t.Errorf("%s(%q, %q) = %q; want nil", trimmer.name, tc.in, tc.f.name, actual)
			}

//			log.Fatal(err)
//		}
//
//		biggerZip := makeZip("big.zip", bytes.NewReader(bigZip))
//		if err := os.WriteFile("/tmp/bigger.zip", biggerZip, 0666); err != nil {
//			log.Fatal(err)
//		}
//
//		biggestZip := makeZip("bigger.zip", bytes.NewReader(biggerZip))
//		if err := os.WriteFile("/tmp/biggest.zip", biggestZip, 0666); err != nil {
//			log.Fatal(err)
//		}
//	}
//

pkg syscall (freebsd-riscv64), const NOTE_TRACKERR = 2 #53466
pkg syscall (freebsd-riscv64), const NOTE_TRACKERR ideal-int #53466
pkg syscall (freebsd-riscv64), const NOTE_TRIGGER = 16777216 #53466
pkg syscall (freebsd-riscv64), const NOTE_TRIGGER ideal-int #53466
pkg syscall (freebsd-riscv64), const NOTE_WRITE = 2 #53466
pkg syscall (freebsd-riscv64), const NOTE_WRITE ideal-int #53466

	// We do not do any explicit checks, just ensure that it does not crash.
	for _, f := range splitTests {
		f()
	}
}

//export goStackCheck
func goStackCheck() {
	// use some stack memory to trigger split stack check
	var buf [256]byte
	use(buf[:])
}

var Used byte

func use(buf []byte) {
	for _, c := range buf {
		Used += c
	}
}

var splitTests = []func(){