generated.go

package interp

import "go/types"

func easyConvToIntFromInt(v Ivalue) Ivalue {
	return int(v.(int))
}

func easyConvToInt8FromInt(v Ivalue) Ivalue {
	return int8(v.(int))
}

func easyConvToInt16FromInt(v Ivalue) Ivalue {
	return int16(v.(int))
}

func easyConvToInt32FromInt(v Ivalue) Ivalue {
	return int32(v.(int))
}

func easyConvToInt64FromInt(v Ivalue) Ivalue {
	return int64(v.(int))
}

func easyConvToUintFromInt(v Ivalue) Ivalue {
	return uint(v.(int))
}

func easyConvToUint8FromInt(v Ivalue) Ivalue {
	return uint8(v.(int))
}

func easyConvToUint16FromInt(v Ivalue) Ivalue {
	return uint16(v.(int))
}

func easyConvToUint32FromInt(v Ivalue) Ivalue {
	return uint32(v.(int))
}

func easyConvToUint64FromInt(v Ivalue) Ivalue {
	return uint64(v.(int))
}

func easyConvToUintptrFromInt(v Ivalue) Ivalue {
	return uintptr(v.(int))
}

func easyConvToFloat32FromInt(v Ivalue) Ivalue {
	return float32(v.(int))
}

func easyConvToFloat64FromInt(v Ivalue) Ivalue {
	return float64(v.(int))
}

func easyConvToIntFromInt8(v Ivalue) Ivalue {
	return int(v.(int8))
}

func easyConvToInt8FromInt8(v Ivalue) Ivalue {
	return int8(v.(int8))
}

func easyConvToInt16FromInt8(v Ivalue) Ivalue {
	return int16(v.(int8))
}

func easyConvToInt32FromInt8(v Ivalue) Ivalue {
	return int32(v.(int8))
}

func easyConvToInt64FromInt8(v Ivalue) Ivalue {
	return int64(v.(int8))
}

func easyConvToUintFromInt8(v Ivalue) Ivalue {
	return uint(v.(int8))
}

func easyConvToUint8FromInt8(v Ivalue) Ivalue {
	return uint8(v.(int8))
}

func easyConvToUint16FromInt8(v Ivalue) Ivalue {
	return uint16(v.(int8))
}

func easyConvToUint32FromInt8(v Ivalue) Ivalue {
	return uint32(v.(int8))
}

func easyConvToUint64FromInt8(v Ivalue) Ivalue {
	return uint64(v.(int8))
}

func easyConvToUintptrFromInt8(v Ivalue) Ivalue {
	return uintptr(v.(int8))
}

func easyConvToFloat32FromInt8(v Ivalue) Ivalue {
	return float32(v.(int8))
}

func easyConvToFloat64FromInt8(v Ivalue) Ivalue {
	return float64(v.(int8))
}

func easyConvToIntFromInt16(v Ivalue) Ivalue {
	return int(v.(int16))
}

func easyConvToInt8FromInt16(v Ivalue) Ivalue {
	return int8(v.(int16))
}

func easyConvToInt16FromInt16(v Ivalue) Ivalue {
	return int16(v.(int16))
}

func easyConvToInt32FromInt16(v Ivalue) Ivalue {
	return int32(v.(int16))
}

func easyConvToInt64FromInt16(v Ivalue) Ivalue {
	return int64(v.(int16))
}

func easyConvToUintFromInt16(v Ivalue) Ivalue {
	return uint(v.(int16))
}

func easyConvToUint8FromInt16(v Ivalue) Ivalue {
	return uint8(v.(int16))
}

func easyConvToUint16FromInt16(v Ivalue) Ivalue {
	return uint16(v.(int16))
}

func easyConvToUint32FromInt16(v Ivalue) Ivalue {
	return uint32(v.(int16))
}

func easyConvToUint64FromInt16(v Ivalue) Ivalue {
	return uint64(v.(int16))
}

func easyConvToUintptrFromInt16(v Ivalue) Ivalue {
	return uintptr(v.(int16))
}

func easyConvToFloat32FromInt16(v Ivalue) Ivalue {
	return float32(v.(int16))
}

func easyConvToFloat64FromInt16(v Ivalue) Ivalue {
	return float64(v.(int16))
}

func easyConvToIntFromInt32(v Ivalue) Ivalue {
	return int(v.(int32))
}

func easyConvToInt8FromInt32(v Ivalue) Ivalue {
	return int8(v.(int32))
}

func easyConvToInt16FromInt32(v Ivalue) Ivalue {
	return int16(v.(int32))
}

func easyConvToInt32FromInt32(v Ivalue) Ivalue {
	return int32(v.(int32))
}

func easyConvToInt64FromInt32(v Ivalue) Ivalue {
	return int64(v.(int32))
}

func easyConvToUintFromInt32(v Ivalue) Ivalue {
	return uint(v.(int32))
}

func easyConvToUint8FromInt32(v Ivalue) Ivalue {
	return uint8(v.(int32))
}

func easyConvToUint16FromInt32(v Ivalue) Ivalue {
	return uint16(v.(int32))
}

func easyConvToUint32FromInt32(v Ivalue) Ivalue {
	return uint32(v.(int32))
}

func easyConvToUint64FromInt32(v Ivalue) Ivalue {
	return uint64(v.(int32))
}

func easyConvToUintptrFromInt32(v Ivalue) Ivalue {
	return uintptr(v.(int32))
}

func easyConvToFloat32FromInt32(v Ivalue) Ivalue {
	return float32(v.(int32))
}

func easyConvToFloat64FromInt32(v Ivalue) Ivalue {
	return float64(v.(int32))
}

func easyConvToIntFromInt64(v Ivalue) Ivalue {
	return int(v.(int64))
}

func easyConvToInt8FromInt64(v Ivalue) Ivalue {
	return int8(v.(int64))
}

func easyConvToInt16FromInt64(v Ivalue) Ivalue {
	return int16(v.(int64))
}

func easyConvToInt32FromInt64(v Ivalue) Ivalue {
	return int32(v.(int64))
}

func easyConvToInt64FromInt64(v Ivalue) Ivalue {
	return int64(v.(int64))
}

func easyConvToUintFromInt64(v Ivalue) Ivalue {
	return uint(v.(int64))
}

func easyConvToUint8FromInt64(v Ivalue) Ivalue {
	return uint8(v.(int64))
}

func easyConvToUint16FromInt64(v Ivalue) Ivalue {
	return uint16(v.(int64))
}

func easyConvToUint32FromInt64(v Ivalue) Ivalue {
	return uint32(v.(int64))
}

func easyConvToUint64FromInt64(v Ivalue) Ivalue {
	return uint64(v.(int64))
}

func easyConvToUintptrFromInt64(v Ivalue) Ivalue {
	return uintptr(v.(int64))
}

func easyConvToFloat32FromInt64(v Ivalue) Ivalue {
	return float32(v.(int64))
}

func easyConvToFloat64FromInt64(v Ivalue) Ivalue {
	return float64(v.(int64))
}

func easyConvToIntFromUint(v Ivalue) Ivalue {
	return int(v.(uint))
}

func easyConvToInt8FromUint(v Ivalue) Ivalue {
	return int8(v.(uint))
}

func easyConvToInt16FromUint(v Ivalue) Ivalue {
	return int16(v.(uint))
}

func easyConvToInt32FromUint(v Ivalue) Ivalue {
	return int32(v.(uint))
}

func easyConvToInt64FromUint(v Ivalue) Ivalue {
	return int64(v.(uint))
}

func easyConvToUintFromUint(v Ivalue) Ivalue {
	return uint(v.(uint))
}

func easyConvToUint8FromUint(v Ivalue) Ivalue {
	return uint8(v.(uint))
}

func easyConvToUint16FromUint(v Ivalue) Ivalue {
	return uint16(v.(uint))
}

func easyConvToUint32FromUint(v Ivalue) Ivalue {
	return uint32(v.(uint))
}

func easyConvToUint64FromUint(v Ivalue) Ivalue {
	return uint64(v.(uint))
}

func easyConvToUintptrFromUint(v Ivalue) Ivalue {
	return uintptr(v.(uint))
}

func easyConvToFloat32FromUint(v Ivalue) Ivalue {
	return float32(v.(uint))
}

func easyConvToFloat64FromUint(v Ivalue) Ivalue {
	return float64(v.(uint))
}

func easyConvToIntFromUint8(v Ivalue) Ivalue {
	return int(v.(uint8))
}

func easyConvToInt8FromUint8(v Ivalue) Ivalue {
	return int8(v.(uint8))
}

func easyConvToInt16FromUint8(v Ivalue) Ivalue {
	return int16(v.(uint8))
}

func easyConvToInt32FromUint8(v Ivalue) Ivalue {
	return int32(v.(uint8))
}

func easyConvToInt64FromUint8(v Ivalue) Ivalue {
	return int64(v.(uint8))
}

func easyConvToUintFromUint8(v Ivalue) Ivalue {
	return uint(v.(uint8))
}

func easyConvToUint8FromUint8(v Ivalue) Ivalue {
	return uint8(v.(uint8))
}

func easyConvToUint16FromUint8(v Ivalue) Ivalue {
	return uint16(v.(uint8))
}

func easyConvToUint32FromUint8(v Ivalue) Ivalue {
	return uint32(v.(uint8))
}

func easyConvToUint64FromUint8(v Ivalue) Ivalue {
	return uint64(v.(uint8))
}

func easyConvToUintptrFromUint8(v Ivalue) Ivalue {
	return uintptr(v.(uint8))
}

func easyConvToFloat32FromUint8(v Ivalue) Ivalue {
	return float32(v.(uint8))
}

func easyConvToFloat64FromUint8(v Ivalue) Ivalue {
	return float64(v.(uint8))
}

func easyConvToIntFromUint16(v Ivalue) Ivalue {
	return int(v.(uint16))
}

func easyConvToInt8FromUint16(v Ivalue) Ivalue {
	return int8(v.(uint16))
}

func easyConvToInt16FromUint16(v Ivalue) Ivalue {
	return int16(v.(uint16))
}

func easyConvToInt32FromUint16(v Ivalue) Ivalue {
	return int32(v.(uint16))
}

func easyConvToInt64FromUint16(v Ivalue) Ivalue {
	return int64(v.(uint16))
}

func easyConvToUintFromUint16(v Ivalue) Ivalue {
	return uint(v.(uint16))
}

func easyConvToUint8FromUint16(v Ivalue) Ivalue {
	return uint8(v.(uint16))
}

func easyConvToUint16FromUint16(v Ivalue) Ivalue {
	return uint16(v.(uint16))
}

func easyConvToUint32FromUint16(v Ivalue) Ivalue {
	return uint32(v.(uint16))
}

func easyConvToUint64FromUint16(v Ivalue) Ivalue {
	return uint64(v.(uint16))
}

func easyConvToUintptrFromUint16(v Ivalue) Ivalue {
	return uintptr(v.(uint16))
}

func easyConvToFloat32FromUint16(v Ivalue) Ivalue {
	return float32(v.(uint16))
}

func easyConvToFloat64FromUint16(v Ivalue) Ivalue {
	return float64(v.(uint16))
}

func easyConvToIntFromUint32(v Ivalue) Ivalue {
	return int(v.(uint32))
}

func easyConvToInt8FromUint32(v Ivalue) Ivalue {
	return int8(v.(uint32))
}

func easyConvToInt16FromUint32(v Ivalue) Ivalue {
	return int16(v.(uint32))
}

func easyConvToInt32FromUint32(v Ivalue) Ivalue {
	return int32(v.(uint32))
}

func easyConvToInt64FromUint32(v Ivalue) Ivalue {
	return int64(v.(uint32))
}

func easyConvToUintFromUint32(v Ivalue) Ivalue {
	return uint(v.(uint32))
}

func easyConvToUint8FromUint32(v Ivalue) Ivalue {
	return uint8(v.(uint32))
}

func easyConvToUint16FromUint32(v Ivalue) Ivalue {
	return uint16(v.(uint32))
}

func easyConvToUint32FromUint32(v Ivalue) Ivalue {
	return uint32(v.(uint32))
}

func easyConvToUint64FromUint32(v Ivalue) Ivalue {
	return uint64(v.(uint32))
}

func easyConvToUintptrFromUint32(v Ivalue) Ivalue {
	return uintptr(v.(uint32))
}

func easyConvToFloat32FromUint32(v Ivalue) Ivalue {
	return float32(v.(uint32))
}

func easyConvToFloat64FromUint32(v Ivalue) Ivalue {
	return float64(v.(uint32))
}

func easyConvToIntFromUint64(v Ivalue) Ivalue {
	return int(v.(uint64))
}

func easyConvToInt8FromUint64(v Ivalue) Ivalue {
	return int8(v.(uint64))
}

func easyConvToInt16FromUint64(v Ivalue) Ivalue {
	return int16(v.(uint64))
}

func easyConvToInt32FromUint64(v Ivalue) Ivalue {
	return int32(v.(uint64))
}

func easyConvToInt64FromUint64(v Ivalue) Ivalue {
	return int64(v.(uint64))
}

func easyConvToUintFromUint64(v Ivalue) Ivalue {
	return uint(v.(uint64))
}

func easyConvToUint8FromUint64(v Ivalue) Ivalue {
	return uint8(v.(uint64))
}

func easyConvToUint16FromUint64(v Ivalue) Ivalue {
	return uint16(v.(uint64))
}

func easyConvToUint32FromUint64(v Ivalue) Ivalue {
	return uint32(v.(uint64))
}

func easyConvToUint64FromUint64(v Ivalue) Ivalue {
	return uint64(v.(uint64))
}

func easyConvToUintptrFromUint64(v Ivalue) Ivalue {
	return uintptr(v.(uint64))
}

func easyConvToFloat32FromUint64(v Ivalue) Ivalue {
	return float32(v.(uint64))
}

func easyConvToFloat64FromUint64(v Ivalue) Ivalue {
	return float64(v.(uint64))
}

func easyConvToIntFromUintptr(v Ivalue) Ivalue {
	return int(v.(uintptr))
}

func easyConvToInt8FromUintptr(v Ivalue) Ivalue {
	return int8(v.(uintptr))
}

func easyConvToInt16FromUintptr(v Ivalue) Ivalue {
	return int16(v.(uintptr))
}

func easyConvToInt32FromUintptr(v Ivalue) Ivalue {
	return int32(v.(uintptr))
}

func easyConvToInt64FromUintptr(v Ivalue) Ivalue {
	return int64(v.(uintptr))
}

func easyConvToUintFromUintptr(v Ivalue) Ivalue {
	return uint(v.(uintptr))
}

func easyConvToUint8FromUintptr(v Ivalue) Ivalue {
	return uint8(v.(uintptr))
}

func easyConvToUint16FromUintptr(v Ivalue) Ivalue {
	return uint16(v.(uintptr))
}

func easyConvToUint32FromUintptr(v Ivalue) Ivalue {
	return uint32(v.(uintptr))
}

func easyConvToUint64FromUintptr(v Ivalue) Ivalue {
	return uint64(v.(uintptr))
}

func easyConvToUintptrFromUintptr(v Ivalue) Ivalue {
	return uintptr(v.(uintptr))
}

func easyConvToFloat32FromUintptr(v Ivalue) Ivalue {
	return float32(v.(uintptr))
}

func easyConvToFloat64FromUintptr(v Ivalue) Ivalue {
	return float64(v.(uintptr))
}

func easyConvToIntFromFloat32(v Ivalue) Ivalue {
	return int(v.(float32))
}

func easyConvToInt8FromFloat32(v Ivalue) Ivalue {
	return int8(v.(float32))
}

func easyConvToInt16FromFloat32(v Ivalue) Ivalue {
	return int16(v.(float32))
}

func easyConvToInt32FromFloat32(v Ivalue) Ivalue {
	return int32(v.(float32))
}

func easyConvToInt64FromFloat32(v Ivalue) Ivalue {
	return int64(v.(float32))
}

func easyConvToUintFromFloat32(v Ivalue) Ivalue {
	return uint(v.(float32))
}

func easyConvToUint8FromFloat32(v Ivalue) Ivalue {
	return uint8(v.(float32))
}

func easyConvToUint16FromFloat32(v Ivalue) Ivalue {
	return uint16(v.(float32))
}

func easyConvToUint32FromFloat32(v Ivalue) Ivalue {
	return uint32(v.(float32))
}

func easyConvToUint64FromFloat32(v Ivalue) Ivalue {
	return uint64(v.(float32))
}

func easyConvToUintptrFromFloat32(v Ivalue) Ivalue {
	return uintptr(v.(float32))
}

func easyConvToFloat32FromFloat32(v Ivalue) Ivalue {
	return float32(v.(float32))
}

func easyConvToFloat64FromFloat32(v Ivalue) Ivalue {
	return float64(v.(float32))
}

func easyConvToIntFromFloat64(v Ivalue) Ivalue {
	return int(v.(float64))
}

func easyConvToInt8FromFloat64(v Ivalue) Ivalue {
	return int8(v.(float64))
}

func easyConvToInt16FromFloat64(v Ivalue) Ivalue {
	return int16(v.(float64))
}

func easyConvToInt32FromFloat64(v Ivalue) Ivalue {
	return int32(v.(float64))
}

func easyConvToInt64FromFloat64(v Ivalue) Ivalue {
	return int64(v.(float64))
}

func easyConvToUintFromFloat64(v Ivalue) Ivalue {
	return uint(v.(float64))
}

func easyConvToUint8FromFloat64(v Ivalue) Ivalue {
	return uint8(v.(float64))
}

func easyConvToUint16FromFloat64(v Ivalue) Ivalue {
	return uint16(v.(float64))
}

func easyConvToUint32FromFloat64(v Ivalue) Ivalue {
	return uint32(v.(float64))
}

func easyConvToUint64FromFloat64(v Ivalue) Ivalue {
	return uint64(v.(float64))
}

func easyConvToUintptrFromFloat64(v Ivalue) Ivalue {
	return uintptr(v.(float64))
}

func easyConvToFloat32FromFloat64(v Ivalue) Ivalue {
	return float32(v.(float64))
}

func easyConvToFloat64FromFloat64(v Ivalue) Ivalue {
	return float64(v.(float64))
}

func easyConvFunc(desT, srcT types.BasicKind) func(Ivalue) Ivalue {
	switch srcT {
	case types.Int:
		switch desT {
		case types.Int:
			return easyConvToIntFromInt
		case types.Int8:
			return easyConvToInt8FromInt
		case types.Int16:
			return easyConvToInt16FromInt
		case types.Int32:
			return easyConvToInt32FromInt
		case types.Int64:
			return easyConvToInt64FromInt
		case types.Uint:
			return easyConvToUintFromInt
		case types.Uint8:
			return easyConvToUint8FromInt
		case types.Uint16:
			return easyConvToUint16FromInt
		case types.Uint32:
			return easyConvToUint32FromInt
		case types.Uint64:
			return easyConvToUint64FromInt
		case types.Uintptr:
			return easyConvToUintptrFromInt
		case types.Float32:
			return easyConvToFloat32FromInt
		case types.Float64:
			return easyConvToFloat64FromInt
		}
	case types.Int8:
		switch desT {
		case types.Int:
			return easyConvToIntFromInt8
		case types.Int8:
			return easyConvToInt8FromInt8
		case types.Int16:
			return easyConvToInt16FromInt8
		case types.Int32:
			return easyConvToInt32FromInt8
		case types.Int64:
			return easyConvToInt64FromInt8
		case types.Uint:
			return easyConvToUintFromInt8
		case types.Uint8:
			return easyConvToUint8FromInt8
		case types.Uint16:
			return easyConvToUint16FromInt8
		case types.Uint32:
			return easyConvToUint32FromInt8
		case types.Uint64:
			return easyConvToUint64FromInt8
		case types.Uintptr:
			return easyConvToUintptrFromInt8
		case types.Float32:
			return easyConvToFloat32FromInt8
		case types.Float64:
			return easyConvToFloat64FromInt8
		}
	case types.Int16:
		switch desT {
		case types.Int:
			return easyConvToIntFromInt16
		case types.Int8:
			return easyConvToInt8FromInt16
		case types.Int16:
			return easyConvToInt16FromInt16
		case types.Int32:
			return easyConvToInt32FromInt16
		case types.Int64:
			return easyConvToInt64FromInt16
		case types.Uint:
			return easyConvToUintFromInt16
		case types.Uint8:
			return easyConvToUint8FromInt16
		case types.Uint16:
			return easyConvToUint16FromInt16
		case types.Uint32:
			return easyConvToUint32FromInt16
		case types.Uint64:
			return easyConvToUint64FromInt16
		case types.Uintptr:
			return easyConvToUintptrFromInt16
		case types.Float32:
			return easyConvToFloat32FromInt16
		case types.Float64:
			return easyConvToFloat64FromInt16
		}
	case types.Int32:
		switch desT {
		case types.Int:
			return easyConvToIntFromInt32
		case types.Int8:
			return easyConvToInt8FromInt32
		case types.Int16:
			return easyConvToInt16FromInt32
		case types.Int32:
			return easyConvToInt32FromInt32
		case types.Int64:
			return easyConvToInt64FromInt32
		case types.Uint:
			return easyConvToUintFromInt32
		case types.Uint8:
			return easyConvToUint8FromInt32
		case types.Uint16:
			return easyConvToUint16FromInt32
		case types.Uint32:
			return easyConvToUint32FromInt32
		case types.Uint64:
			return easyConvToUint64FromInt32
		case types.Uintptr:
			return easyConvToUintptrFromInt32
		case types.Float32:
			return easyConvToFloat32FromInt32
		case types.Float64:
			return easyConvToFloat64FromInt32
		}
	case types.Int64:
		switch desT {
		case types.Int:
			return easyConvToIntFromInt64
		case types.Int8:
			return easyConvToInt8FromInt64
		case types.Int16:
			return easyConvToInt16FromInt64
		case types.Int32:
			return easyConvToInt32FromInt64
		case types.Int64:
			return easyConvToInt64FromInt64
		case types.Uint:
			return easyConvToUintFromInt64
		case types.Uint8:
			return easyConvToUint8FromInt64
		case types.Uint16:
			return easyConvToUint16FromInt64
		case types.Uint32:
			return easyConvToUint32FromInt64
		case types.Uint64:
			return easyConvToUint64FromInt64
		case types.Uintptr:
			return easyConvToUintptrFromInt64
		case types.Float32:
			return easyConvToFloat32FromInt64
		case types.Float64:
			return easyConvToFloat64FromInt64
		}
	case types.Uint:
		switch desT {
		case types.Int:
			return easyConvToIntFromUint
		case types.Int8:
			return easyConvToInt8FromUint
		case types.Int16:
			return easyConvToInt16FromUint
		case types.Int32:
			return easyConvToInt32FromUint
		case types.Int64:
			return easyConvToInt64FromUint
		case types.Uint:
			return easyConvToUintFromUint
		case types.Uint8:
			return easyConvToUint8FromUint
		case types.Uint16:
			return easyConvToUint16FromUint
		case types.Uint32:
			return easyConvToUint32FromUint
		case types.Uint64:
			return easyConvToUint64FromUint
		case types.Uintptr:
			return easyConvToUintptrFromUint
		case types.Float32:
			return easyConvToFloat32FromUint
		case types.Float64:
			return easyConvToFloat64FromUint
		}
	case types.Uint8:
		switch desT {
		case types.Int:
			return easyConvToIntFromUint8
		case types.Int8:
			return easyConvToInt8FromUint8
		case types.Int16:
			return easyConvToInt16FromUint8
		case types.Int32:
			return easyConvToInt32FromUint8
		case types.Int64:
			return easyConvToInt64FromUint8
		case types.Uint:
			return easyConvToUintFromUint8
		case types.Uint8:
			return easyConvToUint8FromUint8
		case types.Uint16:
			return easyConvToUint16FromUint8
		case types.Uint32:
			return easyConvToUint32FromUint8
		case types.Uint64:
			return easyConvToUint64FromUint8
		case types.Uintptr:
			return easyConvToUintptrFromUint8
		case types.Float32:
			return easyConvToFloat32FromUint8
		case types.Float64:
			return easyConvToFloat64FromUint8
		}
	case types.Uint16:
		switch desT {
		case types.Int:
			return easyConvToIntFromUint16
		case types.Int8:
			return easyConvToInt8FromUint16
		case types.Int16:
			return easyConvToInt16FromUint16
		case types.Int32:
			return easyConvToInt32FromUint16
		case types.Int64:
			return easyConvToInt64FromUint16
		case types.Uint:
			return easyConvToUintFromUint16
		case types.Uint8:
			return easyConvToUint8FromUint16
		case types.Uint16:
			return easyConvToUint16FromUint16
		case types.Uint32:
			return easyConvToUint32FromUint16
		case types.Uint64:
			return easyConvToUint64FromUint16
		case types.Uintptr:
			return easyConvToUintptrFromUint16
		case types.Float32:
			return easyConvToFloat32FromUint16
		case types.Float64:
			return easyConvToFloat64FromUint16
		}
	case types.Uint32:
		switch desT {
		case types.Int:
			return easyConvToIntFromUint32
		case types.Int8:
			return easyConvToInt8FromUint32
		case types.Int16:
			return easyConvToInt16FromUint32
		case types.Int32:
			return easyConvToInt32FromUint32
		case types.Int64:
			return easyConvToInt64FromUint32
		case types.Uint:
			return easyConvToUintFromUint32
		case types.Uint8:
			return easyConvToUint8FromUint32
		case types.Uint16:
			return easyConvToUint16FromUint32
		case types.Uint32:
			return easyConvToUint32FromUint32
		case types.Uint64:
			return easyConvToUint64FromUint32
		case types.Uintptr:
			return easyConvToUintptrFromUint32
		case types.Float32:
			return easyConvToFloat32FromUint32
		case types.Float64:
			return easyConvToFloat64FromUint32
		}
	case types.Uint64:
		switch desT {
		case types.Int:
			return easyConvToIntFromUint64
		case types.Int8:
			return easyConvToInt8FromUint64
		case types.Int16:
			return easyConvToInt16FromUint64
		case types.Int32:
			return easyConvToInt32FromUint64
		case types.Int64:
			return easyConvToInt64FromUint64
		case types.Uint:
			return easyConvToUintFromUint64
		case types.Uint8:
			return easyConvToUint8FromUint64
		case types.Uint16:
			return easyConvToUint16FromUint64
		case types.Uint32:
			return easyConvToUint32FromUint64
		case types.Uint64:
			return easyConvToUint64FromUint64
		case types.Uintptr:
			return easyConvToUintptrFromUint64
		case types.Float32:
			return easyConvToFloat32FromUint64
		case types.Float64:
			return easyConvToFloat64FromUint64
		}
	case types.Uintptr:
		switch desT {
		case types.Int:
			return easyConvToIntFromUintptr
		case types.Int8:
			return easyConvToInt8FromUintptr
		case types.Int16:
			return easyConvToInt16FromUintptr
		case types.Int32:
			return easyConvToInt32FromUintptr
		case types.Int64:
			return easyConvToInt64FromUintptr
		case types.Uint:
			return easyConvToUintFromUintptr
		case types.Uint8:
			return easyConvToUint8FromUintptr
		case types.Uint16:
			return easyConvToUint16FromUintptr
		case types.Uint32:
			return easyConvToUint32FromUintptr
		case types.Uint64:
			return easyConvToUint64FromUintptr
		case types.Uintptr:
			return easyConvToUintptrFromUintptr
		case types.Float32:
			return easyConvToFloat32FromUintptr
		case types.Float64:
			return easyConvToFloat64FromUintptr
		}
	case types.Float32:
		switch desT {
		case types.Int:
			return easyConvToIntFromFloat32
		case types.Int8:
			return easyConvToInt8FromFloat32
		case types.Int16:
			return easyConvToInt16FromFloat32
		case types.Int32:
			return easyConvToInt32FromFloat32
		case types.Int64:
			return easyConvToInt64FromFloat32
		case types.Uint:
			return easyConvToUintFromFloat32
		case types.Uint8:
			return easyConvToUint8FromFloat32
		case types.Uint16:
			return easyConvToUint16FromFloat32
		case types.Uint32:
			return easyConvToUint32FromFloat32
		case types.Uint64:
			return easyConvToUint64FromFloat32
		case types.Uintptr:
			return easyConvToUintptrFromFloat32
		case types.Float32:
			return easyConvToFloat32FromFloat32
		case types.Float64:
			return easyConvToFloat64FromFloat32
		}
	case types.Float64:
		switch desT {
		case types.Int:
			return easyConvToIntFromFloat64
		case types.Int8:
			return easyConvToInt8FromFloat64
		case types.Int16:
			return easyConvToInt16FromFloat64
		case types.Int32:
			return easyConvToInt32FromFloat64
		case types.Int64:
			return easyConvToInt64FromFloat64
		case types.Uint:
			return easyConvToUintFromFloat64
		case types.Uint8:
			return easyConvToUint8FromFloat64
		case types.Uint16:
			return easyConvToUint16FromFloat64
		case types.Uint32:
			return easyConvToUint32FromFloat64
		case types.Uint64:
			return easyConvToUint64FromFloat64
		case types.Uintptr:
			return easyConvToUintptrFromFloat64
		case types.Float32:
			return easyConvToFloat32FromFloat64
		case types.Float64:
			return easyConvToFloat64FromFloat64
		}
	}

	return nil
}