// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[ToNearestEven-0]
	_ = x[ToNearestAway-1]
	_ = x[ToZero-2]
	_ = x[AwayFromZero-3]
	_ = x[ToNegativeInf-4]
	_ = x[ToPositiveInf-5]
}

const _RoundingMode_name = "ToNearestEvenToNearestAwayToZeroAwayFromZeroToNegativeInfToPositiveInf"

			f := new(big.Float).SetPrec(2).SetMode(mode).SetFloat64(f64)
			fmt.Printf("  %*g", len(mode.String()), f)
		}
		fmt.Println()
	}

	// Output:
	//    x  ToNearestEven  ToNearestAway  ToZero  AwayFromZero  ToNegativeInf  ToPositiveInf
	//  2.6              3              3       2             3              2              3
	//  2.5              2              3       2             3              2              3

	for _, test := range floatVals {
		for _, sign := range []string{"", "+", "-"} {
			for _, prec := range []uint{0, 1, 2, 10, 53, 64, 100, 1000} {
				for _, mode := range []RoundingMode{ToNearestEven, ToNearestAway, ToZero, AwayFromZero, ToNegativeInf, ToPositiveInf} {
					medium.Reset() // empty buffer for each test case (in case of failures)
					x := sign + test

					var tx Float
					_, _, err := tx.SetPrec(prec).SetMode(mode).Parse(x, 0)

	}

	// round
	f := z.Float() // rounded to zero
	if mode == ToNearestAway {
		panic("not yet implemented")
	}
	if mode == ToNearestEven && rbit == 1 && (sbit == 1 || sbit == 0 && bit0 != 0) || mode == AwayFromZero {
		// round away from zero
		f.SetMode(ToZero).SetPrec(prec)
		f.Add(f, Bits{int(r) + 1}.Float())
	}
	return f
}

// Float returns the *Float z of the smallest possible precision such that