Data   [24]int8
}

type RawSockaddr struct {
	Len    uint8
	Family uint8
	Data   [14]int8
}

type RawSockaddrAny struct {
	Addr RawSockaddr
	Pad  [92]int8
}

type _Socklen uint32

type Linger struct {
	Onoff  int32
	Linger int32
}

type Iovec struct {
	Base *byte
	Len  uint64
}

type IPMreq struct {
	Multiaddr [4]byte /* in_addr */

// and etc), which C++ doesn't support directly.
template <typename T>
struct NoneT {};

// The following family of struct and struct templates are used to
// represent template lists.  In particular, TemplatesN<T1, T2, ...,
// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
// for Templates0, every struct in the family has two member types:

	func (*U3) N()

	// 
	type U4 struct {
		*u5
	}

	// U4.M should appear as method of U4. 
	func (*U4) M()

	// 
	type V1 struct {
		*V2
		*V5
	}

	// 
	type V2 struct {
		*V3
	}

	// 
	type V3 struct {
		*V4
	}

	// 
	type V4 struct {
		*V5
	}

	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
	func (*V4) M()

	// 

type _[P *T, _ any] struct{}
type _[P *T,] struct{}
type _[P *T, _ any] struct{}
type _[P T] struct{}
type _[P T, _ any] struct{}

type _[P *struct{}] struct{}
type _ [P(*struct{})]struct{}
type _[P []int] struct{}

// a type literal in an |-expression indicates a type parameter list (blank after type parameter list and type)
type _[P *[]int] struct{}
type _[P *T | T, Q T] struct{}
type _[P *[]T | T] struct{}

package P

type T struct {
	x, y int
}

type T2 struct {
	w, z int
}

var _ = [42]T{
	T{},
	T{1, 2},
	T{3, 4},
}

var _ = [...]T{
	T{},
	T{1, 2},
	T{3, 4},
}

var _ = []T{
	T{},
	T{1, 2},
	T{3, 4},
}

var _ = []T{
	T{},
	10: T{1, 2},
	20: T{3, 4},
}

var _ = []struct {
	x, y int
}{
	struct{ x, y int }{},
	10: struct{ x, y int }{1, 2},

package p

type Struct struct {
	X int
	Y float64
}

type BigStruct struct {
	X int
	Y float64
	A [1 << 20]int
	Z string
}

type Empty struct {
}

type Empty1 struct {
	Empty
}

var (
	intp       *int
	arrayp     *[10]int
	array0p    *[0]int
	bigarrayp  *[1 << 26]int
	structp    *Struct
	bigstructp *BigStruct
	emptyp     *Empty

)

func bad() {
	var z = T{_: "verse"} // ERROR "invalid field name _ in struct initializer|expected struct field name|unknown field _ in struct literal of type T"
	_ = z
	_ = T{_: "itinerary"} // ERROR "invalid field name _ in struct initializer|expected struct field name|unknown field _ in struct literal of type T"

	t5  uint64
	t6  uint64
}

type user_fpregs_struct struct {
	f [528]byte
}

type usigset struct {
	us_x__val [16]uint64
}

type sigcontext struct {
	sc_regs   user_regs_struct
	sc_fpregs user_fpregs_struct
}

type stackt struct {
	ss_sp    *byte
	ss_flags int32
	ss_size  uintptr
}

type ucontext struct {
	uc_flags     uint64
	uc_link      *ucontext

TYPES
	// A (should see this) 
	type A struct{}

	// B (should see this) 
	type B struct{}

	// C (should see this) 
	type C struct{}

	// D (should see this) 
	type D struct{}

	// E1 (should see this) 
	type E1 struct{}

	// E (should see this for E2 and E3) 
	type E2 struct{}

	// E (should see this for E2 and E3) 
	type E3 struct{}

	// E4 (should see this) 
	type E4 struct{}

	sa_mask     uint64
}

type siginfoFields struct {
	si_signo int32
	si_errno int32
	si_code  int32
	// below here is a union; si_addr is the only field we use
	si_addr uint64
}

type siginfo struct {
	siginfoFields

	// Pad struct to the max size in the kernel.
	_ [_si_max_size - unsafe.Sizeof(siginfoFields{})]byte
}

type itimerspec struct {
	it_interval timespec
	it_value    timespec