defer a.Free()

	tt := arena.New[T1](a)
	tt.n = 1

	ts := arena.MakeSlice[T1](a, 99, 100)
	if len(ts) != 99 {
		t.Errorf("Slice() len = %d, want 99", len(ts))
	}
	if cap(ts) != 100 {
		t.Errorf("Slice() cap = %d, want 100", cap(ts))
	}
	ts[1].n = 42
}

func TestSmokeLarge(t *testing.T) {
	a := arena.NewArena()
	defer a.Free()
	for i := 0; i < 10*64; i++ {
		_ = arena.New[T2](a)
	}

			if !reflect.DeepEqual(a, b) {
				t.Errorf("Split disagrees withSplitN(%q, %q, %d) = %v; want %v", tt.s, tt.sep, tt.n, b, a)
			}
		}
		if len(a) > 0 {
			in, out := a[0], s
			if cap(in) == cap(out) && &in[:1][0] == &out[:1][0] {
				t.Errorf("Join(%#v, %q) didn't copy", a, tt.sep)
			}
		}
	}
}

var splitaftertests = []SplitTest{
	{abcd, "a", -1, []string{"a", "bcd"}},

pkg syscall (freebsd-arm), const SYS_ACCEPT4 ideal-int
pkg syscall (freebsd-arm), const SYS_BINDAT = 538
pkg syscall (freebsd-arm), const SYS_BINDAT ideal-int
pkg syscall (freebsd-arm), const SYS_CAP_GETRIGHTS = 515
pkg syscall (freebsd-arm), const SYS_CAP_GETRIGHTS ideal-int
pkg syscall (freebsd-arm), const SYS_CHFLAGSAT = 540
pkg syscall (freebsd-arm), const SYS_CHFLAGSAT ideal-int
pkg syscall (freebsd-arm), const SYS_CONNECTAT = 539

pkg bufio, method (*Reader) Discard(int) (int, error)
pkg bufio, method (ReadWriter) Discard(int) (int, error)
pkg bytes, func LastIndexByte([]uint8, uint8) int
pkg bytes, method (*Buffer) Cap() int
pkg bytes, method (*Reader) Size() int64
pkg crypto, const SHA512_224 = 14
pkg crypto, const SHA512_224 Hash
pkg crypto, const SHA512_256 = 15
pkg crypto, const SHA512_256 Hash

pkg syscall (freebsd-arm64), const SYS_CAP_GETMODE ideal-int
pkg syscall (freebsd-arm64), const SYS_CAP_IOCTLS_GET = 535
pkg syscall (freebsd-arm64), const SYS_CAP_IOCTLS_GET ideal-int
pkg syscall (freebsd-arm64), const SYS_CAP_IOCTLS_LIMIT = 534
pkg syscall (freebsd-arm64), const SYS_CAP_IOCTLS_LIMIT ideal-int
pkg syscall (freebsd-arm64), const SYS_CAP_RIGHTS_LIMIT = 533
pkg syscall (freebsd-arm64), const SYS_CAP_RIGHTS_LIMIT ideal-int

pkg syscall (freebsd-riscv64), const SYS_CAP_GETMODE ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_CAP_IOCTLS_GET = 535 #53466
pkg syscall (freebsd-riscv64), const SYS_CAP_IOCTLS_GET ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_CAP_IOCTLS_LIMIT = 534 #53466
pkg syscall (freebsd-riscv64), const SYS_CAP_IOCTLS_LIMIT ideal-int #53466

pkg runtime/debug, type Module struct, Sum string
pkg runtime/debug, type Module struct, Version string
pkg strings, func ReplaceAll(string, string, string) string
pkg strings, method (*Builder) Cap() int
pkg syscall (freebsd-386), const S_IRWXG = 56
pkg syscall (freebsd-386), const S_IRWXG ideal-int
pkg syscall (freebsd-386), const S_IRWXO = 7
pkg syscall (freebsd-386), const S_IRWXO ideal-int

</p>

<pre>
s := make([]int, 10, 100)       // slice with len(s) == 10, cap(s) == 100
s := make([]int, 1e3)           // slice with len(s) == cap(s) == 1000
s := make([]int, 1&lt;&lt;63)         // illegal: len(s) is not representable by a value of type int
s := make([]int, 10, 0)         // illegal: len(s) > cap(s)
c := make(chan int, 10)         // channel with a buffer size of 10

	nesting := 0
	colon := -1
	for tok != '\n' && tok != ';' {
		// Process one operand.
		var items []lex.Token
		if cap(operands) > len(operands) {
			// Reuse scratch items slice.
			items = operands[:cap(operands)][len(operands)][:0]
		} else {
			items = make([]lex.Token, 0, 3)
		}
		for {
			tok = p.nextToken()
			if len(operands) == 0 && len(items) == 0 {

			t.Size = c.ptrSize * 2
			t.Align = c.ptrSize
			break
		}
		if dt.Name == "_GoBytes_" {
			// Special C name for Go []byte type.
			// Knows slice layout used by compilers: pointer, length, cap.
			t.Go = c.Ident("[]byte")
			t.Size = c.ptrSize + 4 + 4
			t.Align = c.ptrSize
			break
		}
		name := c.Ident("_Ctype_" + dt.Name)
		goIdent[name.Name] = name
		akey := ""