b = bytes.TrimPrefix(b, []byte("Goodbye,"))
	b = bytes.TrimPrefix(b, []byte("See ya,"))
	fmt.Printf("Hello%s", b)
	// Output: Hello, world!
}

func ExampleTrimSpace() {
	fmt.Printf("%s", bytes.TrimSpace([]byte(" \t\n a lone gopher \n\t\r\n")))
	// Output: a lone gopher
}

func ExampleTrimSuffix() {
	var b = []byte("Hello, goodbye, etc!")
	b = bytes.TrimSuffix(b, []byte("goodbye, etc!"))

<!--
NOTE: In this document and others in this directory, the convention is to
set fixed-width phrases with non-fixed-width spaces, as in
`hello` `world`.
-->

<style>
  main ul li { margin: 0.5em 0; }
</style>

package bufio_test

import (
	"bufio"
	"bytes"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func ExampleWriter() {
	w := bufio.NewWriter(os.Stdout)
	fmt.Fprint(w, "Hello, ")
	fmt.Fprint(w, "world!")
	w.Flush() // Don't forget to flush!
	// Output: Hello, world!
}

func ExampleWriter_AvailableBuffer() {
	w := bufio.NewWriter(os.Stdout)
	for _, i := range []int64{1, 2, 3, 4} {
		b := w.AvailableBuffer()

pkg syscall (darwin-arm64), const IPPROTO_GRE = 47
pkg syscall (darwin-arm64), const IPPROTO_GRE ideal-int
pkg syscall (darwin-arm64), const IPPROTO_HELLO = 63
pkg syscall (darwin-arm64), const IPPROTO_HELLO ideal-int
pkg syscall (darwin-arm64), const IPPROTO_HMP = 20
pkg syscall (darwin-arm64), const IPPROTO_HMP ideal-int
pkg syscall (darwin-arm64), const IPPROTO_HOPOPTS = 0

pkg syscall (freebsd-arm64), const IPPROTO_GRE = 47
pkg syscall (freebsd-arm64), const IPPROTO_GRE ideal-int
pkg syscall (freebsd-arm64), const IPPROTO_HELLO = 63
pkg syscall (freebsd-arm64), const IPPROTO_HELLO ideal-int
pkg syscall (freebsd-arm64), const IPPROTO_HMP = 20
pkg syscall (freebsd-arm64), const IPPROTO_HMP ideal-int
pkg syscall (freebsd-arm64), const IPPROTO_HOPOPTS = 0

pkg syscall (freebsd-riscv64), const IPPROTO_GRE = 47 #53466
pkg syscall (freebsd-riscv64), const IPPROTO_GRE ideal-int #53466
pkg syscall (freebsd-riscv64), const IPPROTO_HELLO = 63 #53466
pkg syscall (freebsd-riscv64), const IPPROTO_HELLO ideal-int #53466
pkg syscall (freebsd-riscv64), const IPPROTO_HMP = 20 #53466
pkg syscall (freebsd-riscv64), const IPPROTO_HMP ideal-int #53466

//
//	slice = append(slice, elem1, elem2)
//	slice = append(slice, anotherSlice...)
//
// As a special case, it is legal to append a string to a byte slice, like this:
//
//	slice = append([]byte("hello "), "world"...)
func append(slice []Type, elems ...Type) []Type

// The copy built-in function copies elements from a source slice into a
// destination slice. (As a special case, it also will copy bytes from a

var b = make([]byte, 5)
n1 := copy(s, a[0:])            // n1 == 6, s is []int{0, 1, 2, 3, 4, 5}
n2 := copy(s, s[2:])            // n2 == 4, s is []int{2, 3, 4, 5, 4, 5}
n3 := copy(b, "Hello, World!")  // n3 == 5, b is []byte("Hello")
</pre>


<h3 id="Clear">Clear</h3>

<p>
The built-in function <code>clear</code> takes an argument of <a href="#Map_types">map</a>,

			a[j+1] = b[j+1]
		}
	}
}

func BenchmarkCompareBytesEqual(b *testing.B) {
	b1 := []byte("Hello Gophers!")
	b2 := []byte("Hello Gophers!")
	for i := 0; i < b.N; i++ {
		if Compare(b1, b2) != 0 {
			b.Fatal("b1 != b2")
		}
	}
}

func BenchmarkCompareBytesToNil(b *testing.B) {
	b1 := []byte("Hello Gophers!")
	var b2 []byte
	for i := 0; i < b.N; i++ {
		if Compare(b1, b2) != 1 {

<p>
For example, in this program:
</p>

<pre>
var a string

func f() {
	print(a)
}

func hello() {
	a = "hello, world"
	go f()
}
</pre>

<p>
calling <code>hello</code> will print <code>"hello, world"</code>
at some point in the future (perhaps after <code>hello</code> has returned).
</p>

<h3 id="goexit">Goroutine destruction</h3>

<p>