F_CLOSEM                          = 0xa
	F_DUPFD                           = 0x0
	F_DUPFD_CLOEXEC                   = 0xc
	F_FSCTL                           = -0x80000000
	F_FSDIRMASK                       = 0x70000000
	F_FSIN                            = 0x10000000
	F_FSINOUT                         = 0x30000000
	F_FSOUT                           = 0x20000000
	F_FSPRIV                          = 0x8000

	F_CLOSEM                          = 0xa
	F_DUPFD                           = 0x0
	F_DUPFD_CLOEXEC                   = 0xc
	F_FSCTL                           = -0x80000000
	F_FSDIRMASK                       = 0x70000000
	F_FSIN                            = 0x10000000
	F_FSINOUT                         = 0x30000000
	F_FSOUT                           = 0x20000000
	F_FSPRIV                          = 0x8000

			continue
		} else if cfg.Height != tc.height {
			t.Errorf("i=%d: height: got %d, want %d", i, cfg.Height, tc.height)
			continue
		}

		if nPixels := int64(cfg.Width) * int64(cfg.Height); nPixels > 0x7f000000 {
			// In theory, calling Decode would succeed, given several gigabytes
			// of memory. In practice, trying to make a []uint8 big enough to
			// hold all of the pixels can often result in OOM (out of memory).

		return false
	}
	v := p.From.Val.(float64)
	if float64(float32(v)) != v {
		return false
	}
	// Secondly, is this value a normal value?
	ival := int64(math.Float32bits(float32(v)))
	isDenorm := ival&0x7F800000 == 0 && ival&0x007FFFFF != 0
	if !isDenorm {
		p.As = AXXSPLTIDP
		p.From.Type = obj.TYPE_CONST
		p.From.Offset = ival
		// Convert REG_Fx into equivalent REG_VSx
		p.To.Reg = REG_VS0 + (p.To.Reg & 31)
	}

// CHECK:           return %[[VAL_3]] : tensor<1xf32>
// CHECK:         }
func.func @convert_reduce_to_min(%arg0: tensor<1x256xf32>) -> tensor<1xf32> {
  // "0x7F800000" represents INF for f32.
  %0 = mhlo.constant dense<0x7F800000> : tensor<f32>
  %1 = "mhlo.reduce"(%arg0, %0) ({
  ^bb0(%arg1: tensor<f32>, %arg2: tensor<f32>):
    %2 = mhlo.minimum %arg1, %arg2 : tensor<f32>

	b := math.Float64bits(f)
	m := b & ((1 << 52) - 1) // mantissa (a.k.a. significand)
	//          | sign                  | exponent   | mantissa       |
	r := uint32(((b >> 32) & (1 << 31)) | 0x7f800000 | (m >> (52 - 23)))
	return math.Float32frombits(r)
}

// extend32Fto64F converts a float32 value to a float64 value preserving the bit
// pattern of the mantissa.
func extend32Fto64F(f float32) float64 {