}
	if _, err := buf.Peek(1); err != io.EOF {
		t.Fatalf("want EOF got %v", err)
	}

	// Test for issue 3022, not exposing a reader's error on a successful Peek.
	buf = NewReaderSize(dataAndEOFReader("abcd"), 32)
	if s, err := buf.Peek(2); string(s) != "ab" || err != nil {
		t.Errorf(`Peek(2) on "abcd", EOF = %q, %v; want "ab", nil`, string(s), err)
	}
	if s, err := buf.Peek(4); string(s) != "abcd" || err != nil {

<code>len(x)</code> is <a href="#Length_and_capacity">constant</a>,
the range expression is not evaluated.
</p>

<p>
Function calls on the left are evaluated once per iteration.
For each iteration, iteration values are produced as follows
if the respective iteration variables are present:
</p>

<pre class="grammar">

pkg syscall (freebsd-arm64), const DLT_JUNIPER_MONITOR = 164
pkg syscall (freebsd-arm64), const DLT_JUNIPER_MONITOR ideal-int
pkg syscall (freebsd-arm64), const DLT_JUNIPER_PIC_PEER = 174
pkg syscall (freebsd-arm64), const DLT_JUNIPER_PIC_PEER ideal-int
pkg syscall (freebsd-arm64), const DLT_JUNIPER_PPP = 179
pkg syscall (freebsd-arm64), const DLT_JUNIPER_PPP ideal-int
pkg syscall (freebsd-arm64), const DLT_JUNIPER_PPPOE = 167

pkg syscall (freebsd-riscv64), const DLT_JUNIPER_MONITOR = 164 #53466
pkg syscall (freebsd-riscv64), const DLT_JUNIPER_MONITOR ideal-int #53466
pkg syscall (freebsd-riscv64), const DLT_JUNIPER_PIC_PEER = 174 #53466
pkg syscall (freebsd-riscv64), const DLT_JUNIPER_PIC_PEER ideal-int #53466
pkg syscall (freebsd-riscv64), const DLT_JUNIPER_PPP = 179 #53466
pkg syscall (freebsd-riscv64), const DLT_JUNIPER_PPP ideal-int #53466

	switch t.tok {
	case '\n':
		t.line++
	case '-':
		if s.Peek() == '>' {
			s.Next()
			t.tok = ARR
			return ARR
		}
	case '@':
		if s.Peek() == '>' {
			s.Next()
			t.tok = ROT
			return ROT
		}
	case '<':
		if s.Peek() == '<' {
			s.Next()
			t.tok = LSH
			return LSH
		}
	case '>':
		if s.Peek() == '>' {
			s.Next()
			t.tok = RSH
			return RSH
		}
	}

	// spaces or NULs.
	// So we remove leading and trailing NULs and spaces to
	// be sure.
	b = bytes.Trim(b, " \x00")

	if len(b) == 0 {
		return 0
	}
	x, perr := strconv.ParseUint(p.parseString(b), 8, 64)
	if perr != nil {
		p.err = ErrHeader
	}
	return int64(x)
}

func (f *formatter) formatOctal(b []byte, x int64) {
	if !fitsInOctal(len(b), x) {
		x = 0 // Last resort, just write zero

		fmt.Printf("Cut(%q, %q) = %q, %q, %v\n", s, sep, before, after, found)
	}
	show("Gopher", "Go")
	show("Gopher", "ph")
	show("Gopher", "er")
	show("Gopher", "Badger")
	// Output:
	// Cut("Gopher", "Go") = "", "pher", true
	// Cut("Gopher", "ph") = "Go", "er", true
	// Cut("Gopher", "er") = "Goph", "", true
	// Cut("Gopher", "Badger") = "Gopher", "", false
}

func ExampleCutPrefix() {
	show := func(s, sep string) {

pkg syscall (darwin-arm64), const MSG_NEEDSA ideal-int
pkg syscall (darwin-arm64), const MSG_OOB = 1
pkg syscall (darwin-arm64), const MSG_OOB ideal-int
pkg syscall (darwin-arm64), const MSG_PEEK = 2
pkg syscall (darwin-arm64), const MSG_PEEK ideal-int
pkg syscall (darwin-arm64), const MSG_RCVMORE = 16384
pkg syscall (darwin-arm64), const MSG_RCVMORE ideal-int
pkg syscall (darwin-arm64), const MSG_SEND = 4096

	doIssueError := true
	isStatic, abi := p.symRefAttrs(name, doIssueError)

	if p.peek() == '+' || p.peek() == '-' {
		a.Offset = int64(p.expr())
	}
	if isStatic {
		a.Sym = p.ctxt.LookupStatic(name)
	} else {
		a.Sym = p.ctxt.LookupABI(name, abi)
	}
	if p.peek() == scanner.EOF {
		if prefix == 0 && p.isJump {
			// Symbols without prefix or suffix are jump labels.
			return
		}

}

func (in *Input) expectNewline(directive string) {
	tok := in.Stack.Next()
	if tok != '\n' {
		in.expectText("expected newline after", directive)
	}
}

func (in *Input) Next() ScanToken {
	if in.peek {
		in.peek = false
		tok := in.peekToken
		in.text = in.peekText
		return tok
	}
	// If we cannot generate a token after 100 macro invocations, we're in trouble.
	// The usual case is caught by Push, below, but be safe.