pkg p1, type Public interface, Y()
pkg p1, type S struct
pkg p1, type S struct, Public *int
pkg p1, type S struct, Public //deprecated
pkg p1, type S struct, PublicTime Time
pkg p1, type S2 struct
pkg p1, type S2 struct, Extra bool
pkg p1, type S2 struct, embedded S
pkg p1, type S2 struct, embedded S //deprecated
pkg p1, type SI struct
pkg p1, type SI struct, I int
pkg p1, type T struct
pkg p1, type TPtrExported struct

package s

type S0 struct{ f int }
func (S0) m() {}

type S1 struct{ S0 }
type S2 struct{ S1 }
type S3 struct{ S2 }
type S4 struct{ S3 }
type S5 struct{ S4 }
type S6 struct{ S5 }
type S7 struct{ S6 }
type S8 struct{ S7 }
type S9 struct{ S8 }
type S10 struct{ S9 }
type S11 struct{ S10 }
type S12 struct{ S11 }
type S13 struct{ S12 }

var _ = S13{}.f

type off int32
type Mode_t uint32

type Timespec struct {
	Sec  int32
	Nsec int32
}

type Timeval struct {
	Sec  int32
	Usec int32
}

type Timeval32 struct {
	Sec  int32
	Usec int32
}

type Timex struct{}

type Time_t int32

type Tms struct{}

type Utimbuf struct {
	Actime  int32
	Modtime int32
}

type Timezone struct {
	Minuteswest int32
	Dsttime     int32
}

}

func issue4355() {
	type (
	    T1 struct {X int}
	    T2 struct {T1}
	    T3 struct {T2}
	    T4 struct {T2}
	    T5 struct {T3; T4} // X is embedded twice at the same level via T3->T2->T1->X, T4->T2->T1->X
	)

	var t T5
	_ = t.X /* ERROR "ambiguous selector t.X" */
}

func _() {
	type State int
	type A struct{ State }
	type B struct{ fmt.State }
	type T struct{ A; B }

	var t T

	SizeofBpfZbufHeader = 0x20
)

type BpfVersion struct {
	Major uint16
	Minor uint16
}

type BpfStat struct {
	Recv uint32
	Drop uint32
}

type BpfZbuf struct {
	Bufa   *byte
	Bufb   *byte
	Buflen uint32
}

type BpfProgram struct {
	Len   uint32
	Insns *BpfInsn
}

type BpfInsn struct {
	Code uint16
	Jt   uint8
	Jf   uint8
	K    uint32
}

type FpReg struct {
	Q  [32][16]uint8
	Sr uint32
	Cr uint32
	_  [8]byte
}

type FpExtendedPrecision struct{}

type PtraceIoDesc struct {
	Op   int32
	Offs uintptr
	Addr *byte
	Len  uint64
}

type Kevent_t struct {
	Ident  uint64
	Filter int16
	Flags  uint16
	Fflags uint32
	Data   int64
	Udata  *byte
	Ext    [4]uint64
}

type FdSet struct {

type E0[P any] []P
type E1[P any] *P
type E2[P any] struct{ _ P }
type E3[P any] struct{ _ *P }
type E5[P any] struct{ _ [10]P }

type T0 struct {
        _ E0[T0]
}

type T0_ struct {
        E0[T0_]
}

type T1 struct {
        _ E1[T1]
}

type T2 /* ERROR "invalid recursive type" */ struct {
        _ E2[T2]
}

type T3 struct {
        _ E3[T3]
}

	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 */

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{}

}

type miscPlaneTag struct {
	V string `json:"色は匂へど"`
}

type percentSlashTag struct {
	V string `json:"text/html%"` // https://golang.org/issue/2718
}

type punctuationTag struct {
	V string `json:"!#$%&()*+-./:;<=>?@[]^_{|}~ "` // https://golang.org/issue/3546
}

type dashTag struct {
	V string `json:"-,"`
}

type emptyTag struct {
	W string
}

type misnamedTag struct {