MFD_HUGE_16MB                               = 0x60000000
	MFD_HUGE_1GB                                = 0x78000000
	MFD_HUGE_1MB                                = 0x50000000
	MFD_HUGE_256MB                              = 0x70000000
	MFD_HUGE_2GB                                = 0x7c000000
	MFD_HUGE_2MB                                = 0x54000000
	MFD_HUGE_32MB                               = 0x64000000

func (c *ctxt7) chipfloat7(e float64) int {
	ei := math.Float64bits(e)
	l := uint32(int32(ei))
	h := uint32(int32(ei >> 32))

	if l != 0 || h&0xffff != 0 {
		return -1
	}
	h1 := h & 0x7fc00000
	if h1 != 0x40000000 && h1 != 0x3fc00000 {
		return -1
	}
	n := 0

	// sign bit (a)
	if h&0x80000000 != 0 {
		n |= 1 << 7
	}

	// exp sign bit (b)
	if h1 == 0x3fc00000 {

// the specified mean.
func fastexprand(mean int) int32 {
	// Avoid overflow. Maximum possible step is
	// -ln(1/(1<<randomBitCount)) * mean, approximately 20 * mean.
	switch {
	case mean > 0x7000000:
		mean = 0x7000000
	case mean == 0:
		return 0
	}

	// Take a random sample of the exponential distribution exp(-mean*x).
	// The probability distribution function is mean*exp(-mean*x), so the CDF is

		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 {