}

func structs() {
	// basics
	var s, t struct {
		x int
		a [10]float32
		_ bool
	}
	_ = s == t
	_ = s != t
	_ = s /* ERROR "< not defined" */ < t
	_ = s == nil /* ERROR "mismatched types" */

	type S struct {
		x int
		a [10]float32
		_ bool
	}
	type T struct {
		x int
		a [10]float32
		_ bool
	}
	var ss S
	var tt T
	_ = s == ss

  const char* operator()(Float32 f) { return "float32"; }
  template <class T>
  const char* operator()(const T& i) {
    return "else";
  }
};

TEST(VisitTest, Test1) {
  TaggedValue a(Int64(1)), b(Float32(1.1f));
  TaggedValue c = TaggedValue::None();

  ASSERT_EQ(a.visit<const char*>(Visitor()), "int64");
  ASSERT_EQ(b.visit<const char*>(Visitor()), "float32");

	_ = a[1.0<<s]

	_ = make([]int, 1.0)
	_ = make([]int, 1.0<<s)
	_ = make([]int, 1.1 /* ERROR "must be integer" */ <<s)

	_ = float32(1)
	_ = float32(1 /* ERROR "must be integer" */ <<s)
	_ = float32(1.0)
	_ = float32(1.0 /* ERROR "must be integer" */ <<s)
	_ = float32(1.1 /* ERROR "must be integer" */ <<s)

	// TODO(gri) Re-enable these tests once types2 has the go/types fixes.
	//           Issue #52080.

func strmax(x, y string) string {
	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
	}

// Nextafter32 returns the next representable float32 value after x towards y.
//
// Special cases are:
//
//	Nextafter32(x, x)   = x
//	Nextafter32(NaN, y) = NaN
//	Nextafter32(x, NaN) = NaN
func Nextafter32(x, y float32) (r float32) {
	switch {
	case IsNaN(float64(x)) || IsNaN(float64(y)): // special case
		r = float32(NaN())
	case x == y:
		r = x
	case x == 0:
		r = float32(Copysign(float64(Float32frombits(1)), float64(y)))

  @tf.function(input_signature=[{
      'x': tf.TensorSpec([4], tf.float32),
      'y': tf.TensorSpec([5], tf.float32),
      'z': tf.TensorSpec([6], tf.float32),
      'a': tf.TensorSpec([1], tf.float32),
      'b': tf.TensorSpec([2], tf.float32),
      'c': tf.TensorSpec([3], tf.float32),
  }])
  def f0004_dict_many_keys(self, d):
    return

	float64(0.9419163802459202),   // ExpFloat64()

	float32(0.95955694),  // Float32()
	float32(0.8076733),   // Float32()
	float32(0.8135684),   // Float32()
	float32(0.92872405),  // Float32()
	float32(0.97472525),  // Float32()
	float32(0.5485458),   // Float32()
	float32(0.97740936),  // Float32()
	float32(0.042272687), // Float32()
	float32(0.99663067),  // Float32()
	float32(0.035181105), // Float32()

	lo := float64(uint32(y))
	d := hi*(1<<32) + lo
	return d
}

func int64tofloat32(y int64) float32 {
	if y < 0 {
		return -uint64tofloat32(-uint64(y))
	}
	return uint64tofloat32(uint64(y))
}

func uint64tofloat32(y uint64) float32 {
	// divide into top 18, mid 23, and bottom 23 bits.
	// (23-bit integers fit into a float32 without loss.)
	top := uint32(y >> 46)
	mid := uint32(y >> 23 & (1<<23 - 1))

			panic(fmt.Sprintln("float32 map does not treat -0 and +0 as equal for read"))
		}
		m[nz] = "-0"
		if m[pz] != "-0" {
			panic(fmt.Sprintln("float32 map does not treat -0 and +0 as equal for write"))
		}
		if _, ok := m[nana]; ok {
			panic(fmt.Sprintln("float32 map allows NaN lookup (a)"))
		}
		if _, ok := m[nanb]; ok {

		switch c.Type().Kind() {
		case types.TFLOAT32:
			s.WriteFloat32(base.Ctxt, noff, float32(f))
		case types.TFLOAT64:
			s.WriteFloat64(base.Ctxt, noff, f)
		}

	case constant.Complex:
		re, _ := constant.Float64Val(constant.Real(u))
		im, _ := constant.Float64Val(constant.Imag(u))
		switch c.Type().Kind() {
		case types.TCOMPLEX64:
			s.WriteFloat32(base.Ctxt, noff, float32(re))