}
}

//go:noinline
func armFloatWrite(a *[129]float64) {
	// This used to miscompile on arm5.
	// The offset is too big to fit in a load.
	// So the code does:
	//   ldr     r0, [sp, #8]
	//   bl      6f690 <_sfloat>
	//   ldr     fp, [pc, #32]   ; (address of 128.0)
	//   vldr    d0, [fp]
	//   ldr     fp, [pc, #28]   ; (1024)
	//   add     fp, fp, r0
	//   vstr    d0, [fp]

	isFloat(2.5 * f)
	asFloat(f * f)
	isFloat(f * f)
	f *= 4
	asFloat(f / 2.5)
	isFloat(f / 2.5)
	asFloat(2.5 / f)
	isFloat(2.5 / f)
	asFloat(f / f)
	isFloat(f / f)
	f /= 4
	asFloat(f)
	isFloat(f)
	f = 5
	asFloat(*&f)
	isFloat(*&f)
	asFloat(234)
	asFloat(Float(234))
	isFloat(Float(234))
	asFloat(1.2)
	asFloat(Float(i))
	isFloat(Float(i))

	asInt(i)
	isInt(i)

}

}  // namespace

GraphDef DeviceCompilerSerializeTest::GetTestGraph(
    const PartialTensorShape& input_shape) {
  FunctionDef make_test_fn = FunctionDefHelper::Define(
      "TestFn", {"a:float", "b:float", "c:float"}, {"m:float"}, {},
      {{{"d"}, "Add", {"a", "b"}, {{"T", DT_FLOAT}}},
       {{"e"}, "Mul", {"d", "c"}, {{"T", DT_FLOAT}}},
       {{"f"}, "Add", {"e", "a"}, {{"T", DT_FLOAT}}},

}

var (
	intOne     = constant.MakeInt64(1)
	floatOne   = constant.ToFloat(intOne)
	complexOne = constant.ToComplex(intOne)
)

const (
	// Maximum size in bits for big.Ints before signaling
	// overflow and also mantissa precision for big.Floats.
	ConstPrec = 512
)

func BigFloat(v constant.Value) *big.Float {
	f := new(big.Float)
	f.SetPrec(ConstPrec)
	switch u := constant.Val(v).(type) {
	case int64:

  }
  return builder->CreateVector(floatVec);
}

// F32Attr already returns a float as required by flatbuffer builders.
static float ConvertF32AttrForOptionWriter(
    llvm::APFloat f, flatbuffers::FlatBufferBuilder* builder) {
  return f.convertToFloat();
}

// BoolAttr already returns a bool as required by flatbuffer builders.
static bool ConvertBoolAttrForOptionWriter(

    public val KaType.isByte: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.BYTE) }
    public val KaType.isFloat: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.FLOAT) }
    public val KaType.isDouble: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.DOUBLE) }

  FunctionDefLibrary library;

  FunctionDef called_func =
      FunctionDefHelper::Create("TransposeCall",
                                /*in_def=*/{"a:float", "b:int32"},
                                /*out_def=*/{"c:float"}, {},
                                {{{"t0"},
                                  "Transpose",
                                  {"a", "b"},
                                  {

		if t.IsString() {
			return v
		}

	case constant.Int:
		if explicit && t.IsString() {
			return tostr(v)
		}
		fallthrough
	case constant.Float, constant.Complex:
		switch {
		case t.IsInteger():
			v = toint(v)
			return v
		case t.IsFloat():
			v = toflt(v)
			v = truncfltlit(v, t)
			return v
		case t.IsComplex():
			v = tocplx(v)
			v = trunccmplxlit(v, t)
			return v
		}
	}

cui fliter <******@****.***> 1664760731 +0000

// the number +0.0 exactly, with precision 0 and rounding mode [ToNearestEven].
//
// Operations always take pointer arguments (*Float) rather
// than Float values, and each unique Float value requires
// its own unique *Float pointer. To "copy" a Float value,
// an existing (or newly allocated) Float must be set to
// a new value using the [Float.Set] method; shallow copies