Float[] suffix = {(float) 86, (float) 99};
      Float[] all = concat(concat(prefix, elements), suffix);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  private static Float[] concat(Float[] left, Float[] right) {
    Float[] result = new Float[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);
    System.arraycopy(right, 0, result, left.length, right.length);

	if y > x {
		return y
	}
	return x
}

func fmin32(x, y float32) float32 { return fmin(x, y) }
func fmin64(x, y float64) float64 { return fmin(x, y) }
func fmax32(x, y float32) float32 { return fmax(x, y) }
func fmax64(x, y float64) float64 { return fmax(x, y) }

type floaty interface{ ~float32 | ~float64 }

func fmin[F floaty](x, y F) F {
	if y != y || y < x {
		return y
	}
	if x != x || x < y || x != 0 {

		return cmp.Compare(aVal.Uint(), bVal.Uint())
	case reflect.String:
		return cmp.Compare(aVal.String(), bVal.String())
	case reflect.Float32, reflect.Float64:
		return cmp.Compare(aVal.Float(), bVal.Float())
	case reflect.Complex64, reflect.Complex128:
		a, b := aVal.Complex(), bVal.Complex()
		if c := cmp.Compare(real(a), real(b)); c != 0 {
			return c
		}

	_ int = real(2.0)
	_ int = real(3i)

	_ float32 = real(1)
	_ float32 = real('a')
	_ float32 = real(2.1)
	_ float32 = real(3.2i)

	_ float64 = real(1)
	_ float64 = real('a')
	_ float64 = real(2.1)
	_ float64 = real(3.2i)

	_ int = imag(1)
	_ int = imag('a')
	_ int = imag(2.1 + 3i)
	_ int = imag(3i)

	_ float32 = imag(1)
	_ float32 = imag('a')
	_ float32 = imag(2.1 + 3.1i)
	_ float32 = imag(3i)

// Verify that incorrect invocations of the complex predeclared function are detected.
// Does not compile.

package main

type (
	Float32    float32
	Float64    float64
	Complex64  complex64
	Complex128 complex128
)

var (
	f32 float32
	f64 float64
	F32 Float32
	F64 Float64

	c64  complex64
	c128 complex128
	C64  Complex64
	C128 Complex128
)

func F1() int {
	return 1
}

	case reflect.Uint64:
		u64 := rv.Uint()
		if u64 >= 1<<63 {
			return nil, fmt.Errorf("uint64 values with high bit set are not supported")
		}
		return int64(u64), nil
	case reflect.Float32, reflect.Float64:
		return rv.Float(), nil
	case reflect.Bool:
		return rv.Bool(), nil
	case reflect.Slice:
		ek := rv.Type().Elem().Kind()
		if ek == reflect.Uint8 {
			return rv.Bytes(), nil
		}

import jsinterop.annotations.JsPackage;

/** Web specializations for {@link Floats} methods. */
public abstract class FloatsMethodsForWeb {

  @JsMethod(name = "Math.min", namespace = JsPackage.GLOBAL)
  public static native float min(float... array);

  @JsMethod(name = "Math.max", namespace = JsPackage.GLOBAL)
  public static native float max(float... array);

import "fmt"

const (
    F32 = 0.00999999977648258209228515625
    F64 = 0.01000000000000000020816681711721685132943093776702880859375
)

var F = float64(float32(0.01))

func main() {
	// 0.01 rounded to float32 then to float64 is F32.
	// 0.01 represented directly in float64 is F64.
	if F != F32 {
		panic(fmt.Sprintf("F=%.1000g, want %.1000g", F, F32))
	}

		0x8234508000000001, // from issue48807
		1<<56 + 1<<32 + 1,
	} {
		got := float32(i)
		dontwant := float32(float64(i))
		if got == dontwant {
			// The test cases above should be uint64s such that
			// this equality doesn't hold. These examples trigger
			// the case where using an intermediate float64 doesn't work.
			t.Errorf("direct float32 conversion doesn't work: arg=%x got=%x dontwant=%x", i, got, dontwant)
		}
	}

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

// Test that nil checks are removed.
// Optimization is enabled.

package p

func f5(p *float32, q *float64, r *float32, s *float64) float64 {
	x := float64(*p) // ERROR "generated nil check"
	y := *q          // ERROR "generated nil check"
	*r = 7           // ERROR "generated nil check"
	*s = 9           // ERROR "generated nil check"
	return x + y