// Integer reference types
def TF_Int4Ref : TF_TensorFlowType<"Int4Ref", "si4ref">;
def TF_Int8Ref : TF_TensorFlowType<"Int8Ref", "i8ref">;
def TF_Int16Ref : TF_TensorFlowType<"Int16Ref", "i16ref">;
def TF_Int32Ref : TF_TensorFlowType<"Int32Ref", "i32ref">;
def TF_Int64Ref : TF_TensorFlowType<"Int64Ref", "i64ref">;

def TF_Uint4Ref : TF_TensorFlowType<"Uint4Ref", "ui8ref">;

	"I32Eqz",
	"I32Eq",
	"I32Ne",
	"I32LtS",
	"I32LtU",
	"I32GtS",
	"I32GtU",
	"I32LeS",
	"I32LeU",
	"I32GeS",
	"I32GeU",
	"I64Eqz",
	"I64Eq",
	"I64Ne",
	"I64LtS",
	"I64LtU",
	"I64GtS",
	"I64GtU",
	"I64LeS",
	"I64LeU",
	"I64GeS",
	"I64GeU",
	"F32Eq",
	"F32Ne",
	"F32Lt",
	"F32Gt",
	"F32Le",
	"F32Ge",
	"F64Eq",
	"F64Ne",
	"F64Lt",
	"F64Gt",
	"F64Le",
	"F64Ge",

		{name: "I64LeS", asm: "I64LeS", argLength: 2, reg: gp21, typ: "Bool"}, // arg0 <= arg1 (signed)
		{name: "I64LeU", asm: "I64LeU", argLength: 2, reg: gp21, typ: "Bool"}, // arg0 <= arg1 (unsigned)
		{name: "I64GeS", asm: "I64GeS", argLength: 2, reg: gp21, typ: "Bool"}, // arg0 >= arg1 (signed)
		{name: "I64GeU", asm: "I64GeU", argLength: 2, reg: gp21, typ: "Bool"}, // arg0 >= arg1 (unsigned)

(Leq(64|32)F ...) => (F(64|32)Le ...)

(Eq64  ...) => (I64Eq ...)
(Eq32  x y) => (I64Eq (ZeroExt32to64 x) (ZeroExt32to64 y))
(Eq16  x y) => (I64Eq (ZeroExt16to64 x) (ZeroExt16to64 y))
(Eq8   x y) => (I64Eq (ZeroExt8to64  x) (ZeroExt8to64  y))
(EqB   ...) => (I64Eq ...)
(EqPtr ...) => (I64Eq ...)
(Eq(64|32)F ...) => (F(64|32)Eq ...)

(Neq64  ...) => (I64Ne ...)
(Neq32  x y) => (I64Ne (ZeroExt32to64 x) (ZeroExt32to64 y))

package test

import (
	"testing"
)

var boolres bool

var i64res int64

func BenchmarkDivconstI64(b *testing.B) {
	for i := 0; i < b.N; i++ {
		i64res = int64(i) / 7
	}
}

func BenchmarkModconstI64(b *testing.B) {
	for i := 0; i < b.N; i++ {
		i64res = int64(i) % 7
	}
}

func BenchmarkDivisiblePow2constI64(b *testing.B) {
	for i := 0; i < b.N; i++ {

    public final inner class kotlin/jvm/internal/Ref$IntRef
}

public final class ContextKt

public final class Foo {
    // source: 'context.kt'
    public method <init>(): void
    private final static method test$call(p0: Foo, p1: java.lang.String, p2: kotlin.jvm.internal.Ref$IntRef, p3: int): void
    public final method test(p0: java.lang.String): void

func (fd *FD) SetsockoptInt(level, name, arg int) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return syscall.SetsockoptInt(fd.Sysfd, level, name, arg)
}

// SetsockoptInet4Addr wraps the setsockopt network call with an IPv4 address.
func (fd *FD) SetsockoptInet4Addr(level, name int, arg [4]byte) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()

	}
	return err
}

// Shutdown wraps syscall.Shutdown.
func (fd *FD) Shutdown(how int) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return syscall.Shutdown(fd.Sysfd, how)
}

// Fchown wraps syscall.Fchown.
func (fd *FD) Fchown(uid, gid int) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return ignoringEINTR(func() error {

public final class CodeFragment {
    // source: 'fragment.kt'
    public method <init>(): void
    public final static method generated_for_debugger_fun(p0: kotlin.jvm.internal.Ref$IntRef): void
    public final inner class kotlin/jvm/internal/Ref$IntRef

// the internal/poll tests can not be in package poll.

package poll

var Consume = consume

type XFDMutex struct {
	fdMutex
}

func (mu *XFDMutex) Incref() bool {
	return mu.incref()
}

func (mu *XFDMutex) IncrefAndClose() bool {
	return mu.increfAndClose()
}

func (mu *XFDMutex) Decref() bool {
	return mu.decref()
}

func (mu *XFDMutex) RWLock(read bool) bool {