PDEPD R1, R2, R3                        // 7c231138
	PEXTD R1, R2, R3                        // 7c231178
	PLBZ 1234(R1), $0, R3                   // 06000000886104d260000000
	// Note, PLD crosses a 64B boundary, and a nop is inserted between PLBZ and PLD
	PLD 1234(R1), $0, R3                    // 04000000e46104d2
	PLFD 1234(R1), $0, F3                   // 06000000c86104d2
	PLFS 1234567890(R4), $0, F3             // 06004996c06402d2

a number of productions. Go programs may omit most of these semicolons
using the following two rules:
</p>

<ol>
<li>
When the input is broken into tokens, a semicolon is automatically inserted
into the token stream immediately after a line's final token if that token is
<ul>
	<li>an
	    <a href="#Identifiers">identifier</a>
	</li>

	<li>an
	    <a href="#Integer_literals">integer</a>,

	INSERTPS $7, (BX), X2                   // 660f3a211307
	INSERTPS $7, (R11), X2                  // 66410f3a211307
	INSERTPS $7, X2, X2                     // 660f3a21d207
	INSERTPS $7, X11, X2                    // 66410f3a21d307
	INSERTPS $7, (BX), X11                  // 66440f3a211b07
	INSERTPS $7, (R11), X11                 // 66450f3a211b07
	INSERTPS $7, X2, X11                    // 66440f3a21da07

	if strings.Contains(f, "\n") {
		panic("feature contains newlines: " + f)
	}

	if _, dup := w.features[f]; dup {
		panic("duplicate feature inserted: " + f)
	}
	w.features[f] = true

	if verbose {
		log.Printf("feature: %s", f)
	}
}

func needApproval(filename string) bool {
	name := filepath.Base(filename)

	// IDs above that range are defined by third-party vendors.
	// Since ZIP lacked high precision timestamps (nor an official specification
	// of the timezone used for the date fields), many competing extra fields
	// have been invented. Pervasive use effectively makes them "official".
	//
	// See http://mdfs.net/Docs/Comp/Archiving/Zip/ExtraField
	zip64ExtraID       = 0x0001 // Zip64 extended information
	ntfsExtraID        = 0x000a // NTFS

pkg runtime/pprof, type Profile struct
pkg sort, func Float64s([]float64)
pkg sort, func Float64sAreSorted([]float64) bool
pkg sort, func Ints([]int)
pkg sort, func IntsAreSorted([]int) bool
pkg sort, func IsSorted(Interface) bool
pkg sort, func Search(int, func(int) bool) int
pkg sort, func SearchFloat64s([]float64, float64) int
pkg sort, func SearchInts([]int, int) int
pkg sort, func SearchStrings([]string, string) int

</pre>

<p>
When using a generic function, type arguments may be provided explicitly,
or they may be partially or completely <a href="#Type_inference">inferred</a>
from the context in which the function is used.
Provided that they can be inferred, type argument lists may be omitted entirely if the function is:
</p>

<ul>
<li>
	<a href="#Calls">called</a> with ordinary arguments,
</li>
<li>

func LastIndexFunc(s []byte, f func(r rune) bool) int {
	return lastIndexFunc(s, f, true)
}

// indexFunc is the same as IndexFunc except that if
// truth==false, the sense of the predicate function is
// inverted.
func indexFunc(s []byte, f func(r rune) bool, truth bool) int {
	start := 0
	for start < len(s) {
		wid := 1
		r := rune(s[start])
		if r >= utf8.RuneSelf {
			r, wid = utf8.DecodeRune(s[start:])
		}