Nvcsw    int64
	Nivcsw   int64
}

type Rlimit struct {
	Cur uint64
	Max uint64
}

// { int, short, short } in poll.h
type PollFd struct {
	Fd      int32
	Events  int16
	Revents int16
}

type Stat_t struct { //Linux Definition
	Dev     uint64
	Ino     uint64
	Nlink   uint64
	Mode    uint32
	Uid     uint32
	Gid     uint32
	_       int32
	Rdev    uint64

	Charspare   [80]int8
	Fstypename  [16]byte
	Mntfromname [1024]byte
	Mntonname   [1024]byte
}

type Flock_t struct {
	Start  int64
	Len    int64
	Pid    int32
	Type   int16
	Whence int16
	Sysid  int32
}

type Dirent struct {
	Fileno uint64
	Off    int64
	Reclen uint16
	Type   uint8
	Pad0   uint8
	Namlen uint16
	Pad1   uint16
	Name   [256]int8
}

	Charspare   [80]int8
	Fstypename  [16]byte
	Mntfromname [1024]byte
	Mntonname   [1024]byte
}

type Flock_t struct {
	Start  int64
	Len    int64
	Pid    int32
	Type   int16
	Whence int16
	Sysid  int32
	_      [4]byte
}

type Dirent struct {
	Fileno uint64
	Off    int64
	Reclen uint16
	Type   uint8
	Pad0   uint8
	Namlen uint16
	Pad1   uint16

// license that can be found in the LICENSE file.

package main

import (
	"fmt"
)

type MyStruct struct {
	F0 [0]float64
	F1 byte
	F2 int16
	_  struct {
		F0 uint32
	}
}

func main() {
	p0 := MyStruct{F0: [0]float64{}, F1: byte(27), F2: int16(9887)}
	fmt.Println(p0)

	Cur uint64
	Max uint64
}

type _Pid_t int32

type _Gid_t uint32

type Flock_t struct {
	Type   int16
	Whence int16
	Sysid  uint32
	Pid    int32
	Vfs    int32
	Start  int64
	Len    int64
}

type Stat_t struct {
	Dev      uint64
	Ino      uint64
	Mode     uint32
	Nlink    int16
	Flag     uint16
	Uid      uint32
	Gid      uint32
	Rdev     uint64
	Ssize    int32
	Atim     StTimespec_t

package main

type I1 interface {
	int8 | int16 | int32 | int64 | int | uint
}
type I2 interface{ float32 | float64 }
type I3 interface{ string }

func F[G1 I1, G2 I2, G3 I3]() {
	var m0 map[G2]rune
	var ch0, ch1 chan bool
	var ast0, ast1 []struct{ s0 G3 }
	var ai64_2 []int64
	var m1, m2, m3 map[bool]map[int]struct {
		m0 map[G2]byte
		s1 G3
	}
	var i8_0, i8_1 G1
	var i16_0 int16

	}
	return r
}

//go:noinline
func cmovClobberAX32(v1, v2 int32, x1, x2 float64) int32 {
	r := v1
	if x1 == x2 {
		r = v2
	}
	return r
}

//go:noinline
func cmovClobberAX16(v1, v2 int16, x1, x2 float64) int16 {
	r := v1
	if x1 == x2 {
		r = v2
	}
	return r
}

func main() {
	if cmovClobberAX16(1, 2, 4.0, 5.0) != 1 {
		panic("CMOVQEQF causes incorrect code")
	}

// license that can be found in the LICENSE file.

package main

func f[T any](i interface{}) {
	switch i.(type) {
	case T:
		println("T")
	case int:
		println("int")
	case int32, int16:
		println("int32/int16")
	case struct{ a, b T }:
		println("struct{T,T}")
	default:
		println("other")
	}
}
func main() {
	f[float64](float64(6))
	f[float64](int(7))
	f[float64](int32(8))

			obj:  uint32(math.MaxUint32),
		},
		{
			name: "uint32 zero",
			obj:  uint32(0),
		},
		{
			name: "int16 max",
			obj:  int16(math.MaxInt16),
		},
		{
			name: "int16 min",
			obj:  int16(math.MinInt16),
		},
		{
			name: "int16 zero",
			obj:  int16(math.MinInt16),
		},
		{
			name: "uint16 max",
			obj:  uint16(math.MaxUint16),
		},
		{
			name: "uint16 zero",

	_ [3]byte
	b [2]uint16 // offset: 6
	_ [2]byte
	c [2]uint32 // offset: 12
	_ [2]byte
	d [2]int16 // offset: 22
	_ [2]byte
	e [2]int32 // offset: 28
}

var Source, Sink T

func newT() T {
	return T{
		a: [2]byte{1, 2},
		b: [2]uint16{1, 2},
		c: [2]uint32{1, 2},
		d: [2]int16{1, 2},
		e: [2]int32{1, 2},
	}
}

//go:noinline
func moves() {
	Sink.a = Source.a
	Sink.b = Source.b