if (!MatchIota(reduce_op.getDimensions(), iota)) return failure();

    // Match the reduction computation.
    const bool is_float = mlir::isa<FloatType>(operand_init.getElementType());
    if (failed(MatchReduceToArgMinMaxType1(reduce_op, is_float, is_argmax)) &&
        failed(MatchReduceToArgMinMaxType2(reduce_op, is_argmax)))
      return rewriter.notifyMatchFailure(

  auto compute = [](APFloat value) -> APFloat {
    bool loseInfo;
    const llvm::fltSemantics& original_float_semantics = value.getSemantics();
    value.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
                  &loseInfo);
    float f = value.convertToFloat();
    APFloat result(1.f / std::sqrt(f));
    result.convert(original_float_semantics, APFloat::rmNearestTiesToEven,

// of the tensor dimension.
bool FloatValueEquals(const Attribute& attr, const double value) {
  const auto fp_attr = mlir::dyn_cast_or_null<DenseFPElementsAttr>(attr);
  if (!fp_attr) return false;

  if (fp_attr.isSplat()) {
    return fp_attr.getSplatValue<APFloat>().isExactlyValue(value);
  }
  return llvm::all_of(fp_attr.getValues<APFloat>(), [value](const APFloat& f) {

    auto element_type = attr.getType().getElementType();
    if (attr.getNumElements() != 1 || !element_type.isIntOrFloat())
      return false;
    if (mlir::isa<FloatType>(element_type)) {
      auto value = *attr.value_begin<APFloat>();
      return value.isNegative() && value.isInfinity();
    } else if (element_type.isInteger(1)) {
      auto value = *attr.value_begin<APInt>();
      return value.isZero();
    } else {

	return &Value{value: b}
}

// FromArray creates a Value from an array of values.
func FromArray(a []Value) *Value {
	return &Value{value: a}
}

// ToFloat works for int and float values
func (v Value) ToFloat() (val float64, ok bool) {
	switch x := v.value.(type) {
	case float64:
		return x, true
	case int64:
		return float64(x), true
	}
	return 0, false
}

			n.Uint64 = u
		}
	}
	// If an integer extraction succeeded, promote the float.
	if n.IsInt {
		n.IsFloat = true
		n.Float64 = float64(n.Int64)
	} else if n.IsUint {
		n.IsFloat = true
		n.Float64 = float64(n.Uint64)
	} else {
		f, err := strconv.ParseFloat(text, 64)
		if err == nil {
			// If we parsed it as a float but it looks like an integer,
			// it's a huge number too large to fit in an int. Reject it.

	_NSIG   = 14  // number of signals in sigtable array
	_ERRMAX = 128 // max length of note string

	// Notes in runtime·sigtab that are handled by runtime·sigpanic.
	_SIGRFAULT = 2
	_SIGWFAULT = 3
	_SIGINTDIV = 4
	_SIGFLOAT  = 5
	_SIGTRAP   = 6
	_SIGPROF   = 0 // dummy value defined for badsignal
	_SIGQUIT   = 0 // dummy value defined for sighandler

			t.Errorf("did not expect unsigned integer for %q", test.text)
		}
		if test.isFloat {
			if !n.IsFloat {
				t.Errorf("expected float for %q", test.text)
			}
			if n.Float64 != test.float64 {
				t.Errorf("float64 for %q should be %g Is %g", test.text, test.float64, n.Float64)
			}
		} else if n.IsFloat {
			t.Errorf("did not expect float for %q", test.text)
		}
		if test.isComplex {
			if !n.IsComplex {

	// floating point values
	tf0 float32 = 0.
	tf1 float32 = 1.
	tf2 float64 = 4.2e1
	tf3 myfloat = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
	tf4 myfloat = 1e-1

	tf5 = tf0 + tf1
	tf6 = tf1 - tf1
	tf7 = tf2 /* ERROR "mismatched types" */ * tf1
	tf8 = tf3 / tf3
	tf9 = tf3 /* ERROR "not defined" */ % tf3

				return makeInt(i)
			}
		}

	case complexVal:
		if re := ToFloat(x); re.Kind() == Float {
			return ToInt(re)
		}
	}

	return unknownVal{}
}

// ToFloat converts x to a [Float] value if x is representable as a [Float].
// Otherwise it returns an [Unknown].
func ToFloat(x Value) Value {
	switch x := x.(type) {
	case int64Val:
		return i64tor(x) // x is always a small int