}
	case *dwarf.TypedefType:
		// C has much more relaxed rules than Go for
		// implicit type conversions. When the parameter
		// is type T defined as *X, simulate a little of the
		// laxness of C by making the argument *X instead of T.
		if ptr, ok := base(dt.Type).(*dwarf.PtrType); ok {
			// Unless the typedef happens to point to void* since
			// Go has special rules around using unsafe.Pointer.

		f, err := fsys.Open(name)
		if err != nil {
			return err
		}
		defer f.Close()
		_, err = io.Copy(tw, f)
		return err
	})
}

// splitUSTARPath splits a path according to USTAR prefix and suffix rules.
// If the path is not splittable, then it will return ("", "", false).
func splitUSTARPath(name string) (prefix, suffix string, ok bool) {
	length := len(name)
	if length <= nameSize || !isASCII(name) {

types and instead use these constants.
This improves the readability of assembly code, and keeps it robust to
changes in data layout either in the Go type definitions or in the
layout rules used by the Go compiler.
</p>

<p>
Constants are of the form <code>const_<i>name</i></code>.
For example, given the Go declaration <code>const bufSize =

pkg syscall (freebsd-arm64), const SYS_RCTL_GET_RACCT ideal-int
pkg syscall (freebsd-arm64), const SYS_RCTL_GET_RULES = 526
pkg syscall (freebsd-arm64), const SYS_RCTL_GET_RULES ideal-int
pkg syscall (freebsd-arm64), const SYS_RCTL_REMOVE_RULE = 529
pkg syscall (freebsd-arm64), const SYS_RCTL_REMOVE_RULE ideal-int
pkg syscall (freebsd-arm64), const SYS_READ = 3
pkg syscall (freebsd-arm64), const SYS_READ ideal-int

pkg syscall (freebsd-riscv64), const SYS_RCTL_GET_RACCT ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_GET_RULES = 526 #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_GET_RULES ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_REMOVE_RULE = 529 #53466
pkg syscall (freebsd-riscv64), const SYS_RCTL_REMOVE_RULE ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_READ = 3 #53466

// if it becomes too large, WriteRune will panic with [ErrTooLarge].
func (b *Buffer) WriteRune(r rune) (n int, err error) {
	// Compare as uint32 to correctly handle negative runes.
	if uint32(r) < utf8.RuneSelf {
		b.WriteByte(byte(r))
		return 1, nil
	}
	b.lastRead = opInvalid
	m, ok := b.tryGrowByReslice(utf8.UTFMax)
	if !ok {
		m = b.grow(utf8.UTFMax)
	}

}

func ExampleReplaceAll() {
	fmt.Printf("%s\n", bytes.ReplaceAll([]byte("oink oink oink"), []byte("oink"), []byte("moo")))
	// Output:
	// moo moo moo
}

func ExampleRunes() {
	rs := bytes.Runes([]byte("go gopher"))
	for _, r := range rs {
		fmt.Printf("%#U\n", r)
	}
	// Output:
	// U+0067 'g'
	// U+006F 'o'
	// U+0020 ' '
	// U+0067 'g'
	// U+006F 'o'
	// U+0070 'p'
	// U+0068 'h'

// UTF-8-encoded rune as a token. The sequence of runes returned is
// equivalent to that from a range loop over the input as a string, which
// means that erroneous UTF-8 encodings translate to U+FFFD = "\xef\xbf\xbd".
// Because of the Scan interface, this makes it impossible for the client to
// distinguish correctly encoded replacement runes from encoding errors.

pkg syscall (freebsd-386), const SYS_QUOTACTL ideal-int
pkg syscall (freebsd-386), const SYS_RCTL_ADD_RULE ideal-int
pkg syscall (freebsd-386), const SYS_RCTL_GET_LIMITS ideal-int
pkg syscall (freebsd-386), const SYS_RCTL_GET_RACCT ideal-int
pkg syscall (freebsd-386), const SYS_RCTL_GET_RULES ideal-int
pkg syscall (freebsd-386), const SYS_RCTL_REMOVE_RULE ideal-int
pkg syscall (freebsd-386), const SYS_READ ideal-int

// license that can be found in the LICENSE file.

// This input was created by taking the instruction productions in
// the old assembler's (5a's) grammar and hand-writing complete
// instructions for each rule, to guarantee we cover the same space.

#include "../../../../../runtime/textflag.h"

TEXT	foo(SB), DUPOK|NOSPLIT, $0

// ADD
//
//	LTYPE1 cond imsr ',' spreg ',' reg
//	{
//		outcode($1, $2, &$3, $5, &$7);