func (ctx Context64) Add(d, e Decimal64) Decimal64 {
	var dp decParts
	dp.unpack(d)
	var ep decParts
	ep.unpack(e)
	if nan, isNan := checkNan(&dp, &ep); isNan {
		return nan
	}
	if dp.fl == flInf || ep.fl == flInf {
		if dp.fl != flInf {
			return e
		}
		if ep.fl != flInf || ep.sign == dp.sign {
			return d
		}
		return QNaN64
	}
	if dp.significand.lo == 0 {
		return e
	} else if ep.significand.lo == 0 {
		return d
	}
	ep.removeZeros()
	dp.removeZeros()
	sep := dp.separation(&ep)
	if sep < 0 {
		dp, ep = ep, dp
		sep = -sep
	}
	if sep > 17 {
		return dp.original
	}
	var rndStatus discardedDigit
	dp.matchScales128(&ep)
	ans := dp.add128(&ep)
	rndStatus = ans.roundToLo()
	if ans.exp < -expOffset {
		rndStatus = ans.rescale(-expOffset)
	}
	ans.significand.lo = ctx.roundingMode.round(ans.significand.lo, rndStatus)
	if ans.exp >= -expOffset && ans.significand.lo != 0 {
		ans.exp, ans.significand.lo = renormalize(ans.exp, ans.significand.lo)
	}
	if ans.exp > expMax || ans.significand.lo > maxSig {
		return infinities[ans.sign]
	}
	return newFromParts(ans.sign, ans.exp, ans.significand.lo)
}
Add computes d + e
package decimal
func (d Decimal64) Abs() Decimal64 {
	if d.IsNaN() {
		return d
	}
	return Decimal64{^neg64 & uint64(d.bits)}
}
func (d Decimal64) Add(e Decimal64) Decimal64 {
	return DefaultContext.Add(d, e)
}
func (d Decimal64) FMA(e, f Decimal64) Decimal64 {
	return DefaultContext.FMA(d, e, f)
}
func (d Decimal64) Mul(e Decimal64) Decimal64 {
	return DefaultContext.Mul(d, e)
}
func (d Decimal64) Sub(e Decimal64) Decimal64 {
	return d.Add(e.Neg())
}
func (d Decimal64) Quo(e Decimal64) Decimal64 {
	return DefaultContext.Quo(d, e)
}
func (d Decimal64) Cmp(e Decimal64) int {
	var dp decParts
	dp.unpack(d)
	var ep decParts
	ep.unpack(e)
	if _, isNan := checkNan(&dp, &ep); isNan {
		return -2
	}
	if dp.isZero() && ep.isZero() {
		return 0
	}
	if d == e {
		return 0
	}
	d = d.Sub(e)
	return 1 - 2*int(d.bits>>63)
}
func (d Decimal64) Neg() Decimal64 {
	return Decimal64{neg64 ^ d.bits}
}
func (ctx Context64) Quo(d, e Decimal64) Decimal64 {
	var dp decParts
	dp.unpack(d)
	var ep decParts
	ep.unpack(e)
	if nan, isNan := checkNan(&dp, &ep); isNan {
		return nan
	}
	var ans decParts
	ans.sign = dp.sign ^ ep.sign
	if dp.isZero() {
		if ep.isZero() {
			return QNaN64
		}
		return zeroes[ans.sign]
	}
	if dp.isinf() {
		if ep.isinf() {
			return QNaN64
		}
		return infinities[ans.sign]
	}
	if ep.isinf() {
		return zeroes[ans.sign]
	}
	if ep.isZero() {
		return infinities[ans.sign]
	}
	dp.matchSignificandDigits(&ep)
	ans.exp = dp.exp - ep.exp
	for {
		for dp.significand.gt(ep.significand) {
			dp.significand = dp.significand.sub(ep.significand)
			ans.significand = ans.significand.add(uint128T{1, 0})
		}
		if dp.significand == (uint128T{}) || ans.significand.numDecimalDigits() == 16 {
			break
		}
		ans.significand = ans.significand.mulBy10()
		dp.significand = dp.significand.mulBy10()
		ans.exp--
	}
	var rndStatus discardedDigit
	dp.significand = dp.significand.mul64(2)
	if dp.significand == (uint128T{}) {
		rndStatus = eq0
	} else if dp.significand.gt(ep.significand) {
		rndStatus = gt5
	} else if dp.significand.lt(ep.significand) {
		rndStatus = lt5
	} else {
		rndStatus = eq5
	}
	ans.significand.lo = ctx.roundingMode.round(ans.significand.lo, rndStatus)
	if ans.exp < -expOffset {
		rndStatus = ans.rescale(-expOffset)
		ans.significand.lo = ctx.roundingMode.round(ans.significand.lo, rndStatus)
	}
	if ans.exp >= -expOffset && ans.significand.lo != 0 {
		ans.exp, ans.significand.lo = renormalize(ans.exp, ans.significand.lo)
	}
	if ans.significand.lo > maxSig || ans.exp > expMax {
		return infinities[ans.sign]
	}
	return newFromParts(ans.sign, ans.exp, ans.significand.lo)
}
func (d Decimal64) Sqrt() Decimal64 {
	flav, sign, exp, significand := d.parts()
	switch flav {
	case flInf:
		if sign == 1 {
			return QNaN64
		}
		return d
	case flQNaN:
		return d
	case flSNaN:
		return SNaN64
	case flNormal:
	}
	if significand == 0 {
		return d
	}
	if sign == 1 {
		return QNaN64
	}
	if exp&1 == 1 {
		exp--
		significand *= 10
	}
	sqrt := umul64(10*decimal64Base, significand).sqrt()
	exp, significand = renormalize(exp/2-8, sqrt)
	return newFromParts(sign, exp, significand)
}