for len(c.ptrKeys) > 0 {
		dtype := c.ptrKeys[0]
		dtypeKey := dtype.String()
		c.ptrKeys = c.ptrKeys[1:]
		ptrs := c.ptrs[dtypeKey]
		delete(c.ptrs, dtypeKey)

		// Note Type might invalidate c.ptrs[dtypeKey].
		t := c.Type(dtype, pos)
		for _, ptr := range ptrs {
			ptr.Go.(*ast.StarExpr).X = t.Go
			ptr.C.Set("%s*", t.C)
		}
	}
}

pkg syscall (darwin-arm64), const MS_ASYNC ideal-int
pkg syscall (darwin-arm64), const MS_DEACTIVATE = 8
pkg syscall (darwin-arm64), const MS_DEACTIVATE ideal-int
pkg syscall (darwin-arm64), const MS_INVALIDATE = 2
pkg syscall (darwin-arm64), const MS_INVALIDATE ideal-int
pkg syscall (darwin-arm64), const MS_KILLPAGES = 4
pkg syscall (darwin-arm64), const MS_KILLPAGES ideal-int
pkg syscall (darwin-arm64), const MS_SYNC = 16

pkg syscall (freebsd-arm64), const MCL_FUTURE ideal-int
pkg syscall (freebsd-arm64), const MS_ASYNC = 1
pkg syscall (freebsd-arm64), const MS_ASYNC ideal-int
pkg syscall (freebsd-arm64), const MS_INVALIDATE = 2
pkg syscall (freebsd-arm64), const MS_INVALIDATE ideal-int
pkg syscall (freebsd-arm64), const MS_SYNC = 0
pkg syscall (freebsd-arm64), const MS_SYNC ideal-int
pkg syscall (freebsd-arm64), const MSG_CMSG_CLOEXEC = 262144

pkg syscall (freebsd-riscv64), const MS_ASYNC = 1 #53466
pkg syscall (freebsd-riscv64), const MS_ASYNC ideal-int #53466
pkg syscall (freebsd-riscv64), const MS_INVALIDATE = 2 #53466
pkg syscall (freebsd-riscv64), const MS_INVALIDATE ideal-int #53466
pkg syscall (freebsd-riscv64), const MS_SYNC = 0 #53466
pkg syscall (freebsd-riscv64), const MS_SYNC ideal-int #53466

			line = strings.TrimSpace(line)
			if strings.HasPrefix(line, "Pid:\t") {
				// On loaded systems, it is possible
				// for a TID to be reused really
				// quickly. As such, we need to
				// validate that the thread status
				// info we just read is a task of the
				// same process PID as we are
				// currently running, and not a
				// recently terminated thread
				// resurfaced in a different process.

)

// validateSparseEntries reports whether sp is a valid sparse map.
// It does not matter whether sp represents data fragments or hole fragments.
func validateSparseEntries(sp []sparseEntry, size int64) bool {
	// Validate all sparse entries. These are the same checks as performed by
	// the BSD tar utility.
	if size < 0 {
		return false
	}
	var pre sparseEntry
	for _, cur := range sp {
		switch {

	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "reading input:", err)
	}
	fmt.Printf("%d\n", count)
	// Output: 15
}

// Use a Scanner with a custom split function (built by wrapping ScanWords) to validate
// 32-bit decimal input.
func ExampleScanner_custom() {
	// An artificial input source.
	const input = "1234 5678 1234567901234567890"
	scanner := bufio.NewScanner(strings.NewReader(input))

func TestScanRune(t *testing.T) {
	for n, test := range scanTests {
		buf := strings.NewReader(test)
		s := NewScanner(buf)
		s.Split(ScanRunes)
		var i, runeCount int
		var expect rune
		// Use a string range loop to validate the sequence of runes.
		for i, expect = range test {
			if !s.Scan() {
				break
			}
			runeCount++
			got, _ := utf8.DecodeRune(s.Bytes())
			if got != expect {

		key, value, residual, err := parsePAXRecord(sbuf)
		if err != nil {
			return nil, ErrHeader
		}
		sbuf = residual

		switch key {
		case paxGNUSparseOffset, paxGNUSparseNumBytes:
			// Validate sparse header order and value.
			if (len(sparseMap)%2 == 0 && key != paxGNUSparseOffset) ||
				(len(sparseMap)%2 == 1 && key != paxGNUSparseNumBytes) ||
				strings.Contains(value, ",") {
				return nil, ErrHeader

	print(b)
	print(a)
}

func main() {
	go f()
	g()
}
</pre>

<p>
it can happen that <code>g</code> prints <code>2</code> and then <code>0</code>.
</p>

<p>
This fact invalidates a few common idioms.
</p>

<p>
Double-checked locking is an attempt to avoid the overhead of synchronization.
For example, the <code>twoprint</code> program might be
incorrectly written as:
</p>