nproc = 7
	}
	if setNproc {
		var rlim syscall.Rlimit
		if syscall.Getrlimit(nproc, &rlim) == nil {
			max := int(rlim.Cur) / (threads + 5)
			if attempts > max {
				t.Logf("lowering attempts from %d to %d for RLIMIT_NPROC", attempts, max)
				attempts = max
			}
		}
	}

	if os.Getenv("test18146") == "exec" {
		runtime.GOMAXPROCS(1)
		for n := threads; n > 0; n-- {
			go func() {

// Exported for testing only.
import (
	"unicode/utf8"
)

var IsSpace = isSpace

const DefaultBufSize = defaultBufSize

func (s *Scanner) MaxTokenSize(n int) {
	if n < utf8.UTFMax || n > 1e9 {
		panic("bad max token size")
	}
	if n < len(s.buf) {
		s.buf = make([]byte, n)
	}
	s.maxTokenSize = n
}

// ErrOrEOF is like Err, but returns EOF. Used to test a corner case.
func (s *Scanner) ErrOrEOF() error {

pkg syscall (freebsd-386), const AF_INET6_SDP ideal-int
pkg syscall (freebsd-386), const AF_INET_SDP = 40
pkg syscall (freebsd-386), const AF_INET_SDP ideal-int
pkg syscall (freebsd-386), const AF_MAX = 42
pkg syscall (freebsd-386), const DLT_MATCHING_MAX = 246
pkg syscall (freebsd-386), const DLT_MPEG_2_TS = 243
pkg syscall (freebsd-386), const DLT_MPEG_2_TS ideal-int
pkg syscall (freebsd-386), const DLT_NFC_LLCP = 245

	case *ast.SliceExpr:
		f.walk(&n.X, ctxExpr, visit)
		if n.Low != nil {
			f.walk(&n.Low, ctxExpr, visit)
		}
		if n.High != nil {
			f.walk(&n.High, ctxExpr, visit)
		}
		if n.Max != nil {
			f.walk(&n.Max, ctxExpr, visit)
		}
	case *ast.TypeAssertExpr:
		f.walk(&n.X, ctxExpr, visit)
		f.walk(&n.Type, ctxType, visit)
	case *ast.CallExpr:
		if context == ctxAssign2 {

pkg syscall (netbsd-arm64-cgo), const ETHER_HDR_LEN ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHER_MAX_LEN = 1518
pkg syscall (netbsd-arm64-cgo), const ETHER_MAX_LEN ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHER_MAX_LEN_JUMBO = 9018
pkg syscall (netbsd-arm64-cgo), const ETHER_MAX_LEN_JUMBO ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERMIN = 46
pkg syscall (netbsd-arm64-cgo), const ETHERMIN ideal-int

	var bb Buffer
	bb.Grow(16 << 20)
	b.SetBytes(int64(bb.Available()))
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		bb.Reset()
		b := bb.AvailableBuffer()
		b = b[:cap(b)] // use max capacity to simulate a large append operation
		bb.Write(b)    // should be nearly infinitely fast
	}

<p>
As for simple slice expressions, if <code>a</code> is a pointer to an array,
<code>a[low : high : max]</code> is shorthand for <code>(*a)[low : high : max]</code>.
If the sliced operand is an array, it must be <a href="#Address_operators">addressable</a>.
</p>

<p>
The indices are <i>in range</i> if <code>0 &lt;= low &lt;= high &lt;= max &lt;= cap(a)</code>,
otherwise they are <i>out of range</i>.

static unsigned int
goDummyCallbackThread(void* p)
{
	int i, max;

	max = *(int*)p;
	for(i=0; i<max; i++)
		goDummy();
	return 0;
}

int
callGoInCThread(int max)
{
	uintptr_t thread_id;
	thread_id = _beginthreadex(0, 0, goDummyCallbackThread, &max, 0, 0);
	WaitForSingleObject((HANDLE)thread_id, INFINITE);
	CloseHandle((HANDLE)thread_id);
	return max;

#cgo LDFLAGS: -framework CoreFoundation -framework Security
#include <TargetConditionals.h>
#include <CoreFoundation/CoreFoundation.h>
#include <Security/Security.h>
#if TARGET_OS_IPHONE == 0 && __MAC_OS_X_VERSION_MAX_ALLOWED < 101200
  typedef CFStringRef SecKeyAlgorithm;
  static CFDataRef SecKeyCreateSignature(SecKeyRef key, SecKeyAlgorithm algorithm, CFDataRef dataToSign, CFErrorRef *error){return NULL;}

pkg syscall (openbsd-amd64-cgo), const S_IRWXO = 7
pkg syscall (openbsd-amd64-cgo), const S_IRWXO ideal-int
pkg syscall (windows-386), const UNIX_PATH_MAX = 108
pkg syscall (windows-386), const UNIX_PATH_MAX ideal-int