if i > 7 {
			dst.gp_regs[i+6] = uint64(src.Ints[i])
		} else {
			dst.gp_regs[i+3] = uint64(src.Ints[i])
		}
	}
	// Fprs F1..F13 are used to pass float arguments in registers on PPC64
	for i := 0; i < 12; i++ {
		dst.fp_regs[i+1] = math.Float64frombits(src.Floats[i])
	}

}

func loadRegArgs(dst *abi.RegArgs, src *sigcontext) {
	// Gprs R3..R10, R14..R17 are used to pass int arguments in registers on PPC64

	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~string
}

func Smallest[T Ordered](s []T) T {
	r := s[0] // panics if slice is empty
	for _, v := range s[1:] {
		if v < r {
			r = v
		}
	}
	return r
}

func main() {
	vec1 := []float64{5.3, 1.2, 32.8}
	vec2 := []string{"abc", "def", "aaa"}

	want1 := 1.2

	// s390x:"MOV(B|BZ|D)\t[$]1,",-"FCMPU",-"MOV(B|BZ|D)\t[$]0,"
	return float32(0.5) <= float32(int64(1)) && float32(1.5) >= float32(int32(-1<<31))
}

// Test that integer constants are converted to floating point constants
// at compile-time

func constantConvert32(x float32) float32 {
	// amd64:"MOVSS\t[$]f32.3f800000\\(SB\\)"
	// s390x:"FMOVS\t[$]f32.3f800000\\(SB\\)"
	// ppc64x/power8:"FMOVS\t[$]f32.3f800000\\(SB\\)"

	if x < 0 {
		x = -x
		sinSign = true
	}

	var j uint64
	var y, z float64
	if x >= reduceThreshold {
		j, z = trigReduce(x)
	} else {
		j = uint64(x * (4 / Pi)) // integer part of x/(Pi/4), as integer for tests on the phase angle
		y = float64(j)           // integer part of x/(Pi/4), as float

		if j&1 == 1 { // map zeros to origin
			j++
			y++
		}

var x5 = "a" + string(1)
var x6 = int(1e100)      // ERROR "overflow|cannot convert"
var x7 = float32(1e1000) // ERROR "overflow|cannot convert"

// unsafe.Pointer can only convert to/from uintptr
var _ = string(unsafe.Pointer(uintptr(65)))  // ERROR "convert|conversion"
var _ = float64(unsafe.Pointer(uintptr(65))) // ERROR "convert|conversion"
var _ = int(unsafe.Pointer(uintptr(65)))     // ERROR "convert|conversion"

			return []string{"-mabi=64", "-mhard-float"}
		} else if gomips64 == "softfloat" {
			return []string{"-mabi=64", "-msoft-float"}
		}
	case "mips", "mipsle":
		if gomips == "hardfloat" {
			return []string{"-mabi=32", "-mfp32", "-mhard-float", "-mno-odd-spreg"}
		} else if gomips == "softfloat" {
			return []string{"-mabi=32", "-msoft-float"}
		}
	case "loong64":

		{`package e0; const _ = float32( 1e-200)`, `float32(1e-200)`, `float32`, `0`},
		{`package e1; const _ = float32(-1e-200)`, `float32(-1e-200)`, `float32`, `0`},
		{`package e2; const _ = float64( 1e-2000)`, `float64(1e-2000)`, `float64`, `0`},
		{`package e3; const _ = float64(-1e-2000)`, `float64(-1e-2000)`, `float64`, `0`},

	dup("[]int"),
	dup("*int"),
	dup("struct{x int}"),
	dup("func()"),
	dup("func(int, float32) string"),
	dup("interface{m()}"),
	dup("interface{m() string; n(x int)}"),
	dup("interface{~int}"),
	dup("interface{~int | ~float64 | ~string}"),
	dup("interface{~int; m()}"),
	dup("interface{~int | ~float64 | ~string; m() string; n(x int)}"),
	dup("map[string]int"),
	dup("chan E"),
	dup("<-chan E"),

  "$_builder.clone(*op0)->getOpResults()", returns>;

// Creates an 1D array const with float values.
class Create1DConst<string values> : NativeCodeCall<
  "Create1DConstValue<float>($_builder, $_loc, "# values #")">;

// Creates a scalar const with float value.
class CreateScalarConst<string value> : NativeCodeCall<
  "CreateScalarConstValue<float>($_builder, $_loc, "# value #")">;

// Creates an 1D array const with integer values.

			return
		}

		x.mode = novalue
		if check.recordTypes() {
			check.recordBuiltinType(call.Fun, makeSig(nil, map_, key))
		}

	case _Imag, _Real:
		// imag(complexT) floatT
		// real(complexT) floatT

		// convert or check untyped argument
		if isUntyped(x.typ) {
			if x.mode == constant_ {
				// an untyped constant number can always be considered
				// as a complex constant