%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]])

  // 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>

}

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)"

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 !bytes.Contains(out, []byte(pos+"\n")) {
					t.Errorf("%s should be reachable. Output:\n%s", pos, out)
				}
			}
			for _, neg := range test.neg {
				if bytes.Contains(out, []byte(neg+"\n")) {
					t.Errorf("%s should not be reachable. Output:\n%s", neg, out)
				}
			}
		})
	}

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

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

		assert(unsafe.Slice((*int)(nil), 0) == nil)

		// nil pointer with positive length panics
		mustPanic(func() { _ = unsafe.Slice((*int)(nil), 1) })

		// negative length
		var neg int = -1
		mustPanic(func() { _ = unsafe.Slice(new(byte), neg) })

		// length too large
		var tooBig uint64 = math.MaxUint64
		mustPanic(func() { _ = unsafe.Slice(new(byte), tooBig) })

		// size overflows address space

	var a uint64

	z &= 63

	// amd64:"ROLQ",-"AND"
	// arm64:"ROR","NEG",-"AND"
	// ppc64x:"ROTL",-"NEG",-"AND"
	// loong64: "ROTRV", -"AND"
	// riscv64: "ROL",-"AND"
	a += x<<z | x>>(64-z)

	// amd64:"RORQ",-"AND"
	// arm64:"ROR",-"NEG",-"AND"
	// ppc64x:"ROTL","NEG",-"AND"
	// loong64: "ROTRV", -"AND"
	// riscv64: "ROR",-"AND"
	a += x>>z | x<<(64-z)

	return a
}