neg := x.neg
	if x.neg == y.neg {
		// x + y == x + y
		// (-x) + (-y) == -(x + y)
		z.abs = z.abs.add(x.abs, y.abs)
	} else {
		// x + (-y) == x - y == -(y - x)
		// (-x) + y == y - x == -(x - y)
		if x.abs.cmp(y.abs) >= 0 {
			z.abs = z.abs.sub(x.abs, y.abs)
		} else {
			neg = !neg
			z.abs = z.abs.sub(y.abs, x.abs)
		}
	}
	z.neg = len(z.abs) > 0 && neg // 0 has no sign
	return z

  %tmp2, %ctl2 = tfl.control_node(%ctl1) controls "tfl.neg"(%tmp1): (tensor<1xf32>) -> tensor<1xf32>
  %tmp3, %ctl3 = tfl.control_node(%ctl2) controls "tfl.neg"(%tmp2): (tensor<1xf32>) -> tensor<1xf32>
  func.return %tmp3: tensor<1xf32>
}
// CHECK-NEXT: %[[t0:.*]], %[[c0:.*]] = tfl.control_node controls "tfl.neg"(%arg0)
// CHECK-NEXT: %[[t1:.*]], %[[c1:.*]] = tfl.control_node(%[[c0]]) controls "tfl.neg"(%[[t0]])

		// Below we set z.neg = x.neg, and when z aliases y this will
		// change the y operand's sign. This is fine, because if an
		// operand aliases the receiver it'll be overwritten, but we still
		// want the original x.neg and y.neg values when we evaluate
		// x.neg != y.neg, so we need to save y.neg before setting z.neg.
		yneg := y.neg

		z.neg = x.neg
		if x.neg == yneg {
			// x + y == x + y

  // CHECK: [[NEG:%.+]] = "tf.Neg"([[ARG0]])
  %0 = "tf.Neg"(%arg0) : (tensor<i32>) -> tensor<i32>
  // CHECK: return [[NEG]]
  func.return %0: tensor<i32>
}

// CHECK-LABEL: func @testDoubleNeg
// CHECK-SAME:  ([[ARG0:%.+]]: tensor<i32>)
func.func @testDoubleNeg(%arg0: tensor<i32>) -> tensor<i32> {
  %0 = "tf.Neg"(%arg0) : (tensor<i32>) -> tensor<i32>
  %1 = "tf.Neg"(%0) : (tensor<i32>) -> tensor<i32>

  // CHECK: %[[EXP:.*]] = "tfl.exp"
  %4 = "tfl.exp"(%3) : (tensor<4xf32>) -> tensor<4xf32> loc("exp")
  // tfl.neg should not be pruned
  // CHECK: %[[NEG:.*]] = "tfl.neg"
  %5 = "tfl.neg"(%4) : (tensor<4xf32>) -> tensor<4xf32> loc("neg")
  // CHECK: return %[[MUL]], %[[EXP]], %[[DIV]]
  func.return %5 : tensor<4xf32>

	}
	return z
}

// Abs sets z to |x| (the absolute value of x) and returns z.
func (z *Rat) Abs(x *Rat) *Rat {
	z.Set(x)
	z.a.neg = false
	return z
}

// Neg sets z to -x and returns z.
func (z *Rat) Neg(x *Rat) *Rat {
	z.Set(x)
	z.a.neg = len(z.a.abs) > 0 && !z.a.neg // 0 has no sign
	return z
}

// Inv sets z to 1/x and returns z.
// If x == 0, Inv panics.
func (z *Rat) Inv(x *Rat) *Rat {

}

func _() {
	var x big.Float
	_ = x.neg // ERROR "x.neg undefined (type big.Float has no field or method neg, but does have method Neg)"
	_ = x.nEg // ERROR "x.nEg undefined (type big.Float has no field or method nEg)"
	_ = x.Neg
	_ = x.NEg // ERROR "x.NEg undefined (type big.Float has no field or method NEg, but does have method Neg)"

	_ = x.form // ERROR "x.form undefined (cannot refer to unexported field form)"

		}
		digs = decimalSlice{d: d.d[:], nd: d.nd, dp: d.dp}
	}
	return formatDigits(dst, shortest, neg, digs, prec, fmt)
}

func formatDigits(dst []byte, shortest bool, neg bool, digs decimalSlice, prec int, fmt byte) []byte {
	switch fmt {
	case 'e', 'E':
		return fmtE(dst, neg, digs, prec, fmt)
	case 'f':
		return fmtF(dst, neg, digs, prec)
	case 'g', 'G':
		// trailing fractional zeros in 'e' form will be trimmed.

attributes {tf.entry_function = {inputs = "input0,input1", outputs = "output0,output1"}} {
  %0 = "tfl.neg"(%arg0) : (tensor<4xi8>) -> tensor<4xi8> loc("neg")
  %1 = "tfl.neg"(%arg1) : (tensor<4xi32>) -> tensor<4xi32> loc("neg")
  func.return %1, %0 : tensor<4xi32>, tensor<4xi8>

			if f, ok := atof32exact(mantissa, exp, neg); ok {
				return f, n, nil
			}
		}
		f, ok := eiselLemire32(mantissa, exp, neg)
		if ok {
			if !trunc {
				return f, n, nil
			}
			// Even if the mantissa was truncated, we may
			// have found the correct result. Confirm by
			// converting the upper mantissa bound.
			fUp, ok := eiselLemire32(mantissa+1, exp, neg)
			if ok && f == fUp {
				return f, n, nil