pkg syscall (darwin-386), const MADV_CAN_REUSE = 9
pkg syscall (darwin-386), const MADV_DONTNEED = 4
pkg syscall (darwin-386), const MADV_FREE = 5
pkg syscall (darwin-386), const MADV_FREE_REUSABLE = 7
pkg syscall (darwin-386), const MADV_FREE_REUSE = 8
pkg syscall (darwin-386), const MADV_NORMAL = 0
pkg syscall (darwin-386), const MADV_RANDOM = 1
pkg syscall (darwin-386), const MADV_SEQUENTIAL = 2

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package issue23555

// #include <stdlib.h>
import "C"

func X() {
	C.free(C.malloc(10))

#include <stdlib.h>
%}

%typemap(gotype) const char * "string"
%typemap(in) const char * %{
	$1 = malloc($input.n + 1);
	memcpy($1, $input.p, $input.n);
	$1[$input.n] = '\0';
%}
%typemap(freearg) const char * %{
	free($1);
%}

FILE *fopen(const char *name, const char *mode);
int fclose(FILE *);

Additional IP Rights Grant (Patents)

"This implementation" means the copyrightable works distributed by
Google as part of the Go project.

Google hereby grants to You a perpetual, worldwide, non-exclusive,
no-charge, royalty-free, irrevocable (except as stated in this section)
patent license to make, have made, use, offer to sell, sell, import,
transfer and otherwise run, modify and propagate the contents of this

In a process of repeated simplification, the bound type parameters in each type
argument are substituted with the respective type arguments for those type
parameters until each type argument is free of bound type parameters.
</p>

<p>
If type arguments contain cyclic references to themselves
through bound type parameters, simplification and thus type
inference fails.

	a := arena.NewArena()
	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++ {

pkg syscall (linux-arm-cgo), type Statfs_t struct, Files uint64
pkg syscall (linux-arm-cgo), type Statfs_t struct, Flags int32
pkg syscall (linux-arm-cgo), type Statfs_t struct, Frsize int32
pkg syscall (linux-arm-cgo), type Statfs_t struct, Fsid Fsid
pkg syscall (linux-arm-cgo), type Statfs_t struct, Namelen int32
pkg syscall (linux-arm-cgo), type Statfs_t struct, Pad_cgo_0 [4]uint8

/* Test calling a Go function with multiple return values.  */

void
callMulti(void)
{
	struct multi_return result = multi();
	assert(strcmp(result.r0, "multi") == 0);
	assert(result.r1 == 0);
	free(result.r0);

pkg syscall (freebsd-riscv64), const MADV_DONTNEED = 4 #53466
pkg syscall (freebsd-riscv64), const MADV_DONTNEED ideal-int #53466
pkg syscall (freebsd-riscv64), const MADV_FREE = 5 #53466
pkg syscall (freebsd-riscv64), const MADV_FREE ideal-int #53466
pkg syscall (freebsd-riscv64), const MADV_NOCORE = 8 #53466
pkg syscall (freebsd-riscv64), const MADV_NOCORE ideal-int #53466

that use-after-free bugs are possible with regular Go values. This package
limits the impact of these use-after-free bugs by preventing reuse of freed
memory regions until the garbage collector is able to determine that it is
safe. Typically, a use-after-free bug will result in a fault and a helpful
error message, but this package reserves the right to not force a fault on