%res2 = "tf.DivNoNan"(%arg0, %comp2) : (tensor<2xcomplex<f32>>, tensor<2xcomplex<f32>>) -> tensor<2xcomplex<f32>>
  %res3 = "tf.MulNoNan"(%arg0, %comp3) : (tensor<2xcomplex<f32>>, tensor<2xcomplex<f32>>) -> tensor<2xcomplex<f32>>
  func.return %res1, %res2, %res3 : tensor<2xcomplex<f32>>, tensor<2xcomplex<f32>>, tensor<2xcomplex<f32>>
}

}

func.func @mul_complex32(%arg0: tensor<14xcomplex<f32>>, %arg1: tensor<14xcomplex<f32>>) -> tensor<14xcomplex<f32>> {
  %0 = "tf.Mul"(%arg0, %arg1) : (tensor<14xcomplex<f32>>, tensor<14xcomplex<f32>>) -> tensor<14xcomplex<f32>>
  func.return %0: tensor<14xcomplex<f32>>

// CHECK-LABEL: mul_complex32
// CHECK:  tfl.mul %arg0, %arg1 {fused_activation_function = "NONE"} : tensor<14xcomplex<f32>>
// CHECK:  return
}

		},
		"add only not nulls": {
			Original: `{}`,
			Current:  `{}`,
			Modified: `{"complex":{"nested":null,"nested2":"foo"}}`,

			ExpectedTwoWay:         `{"complex":{"nested":null,"nested2":"foo"}}`,
			ExpectedTwoWayResult:   `{"complex":{"nested2":"foo"}}`,
			ExpectedThreeWay:       `{"complex":{"nested":null,"nested2":"foo"}}`,
			ExpectedThreeWayResult: `{"complex":{"nested2":"foo"}}`,

  let arguments = (ins
    TFL_TensorOf<[Complex<F<32>>, Complex<F<64>>]>:$input
  );

  let results = (outs
    TFL_TensorOf<[F32, F64]>:$output
  );
}

def TFL_RealOp : TFL_Op<"real", [
  Pure,
  SameOperandsAndResultShape]> {
  let summary = "Returns the real part of a complex number.";

  let description = [{
Given a tensor `input` of complex numbers, this operation returns a tensor of

func.func @testMulComplex(tensor<? x complex<f32>>, tensor<? x complex<f32>>) -> tensor<? x complex<f32>> {
^bb0(%arg0: tensor<? x complex<f32>>, %arg1: tensor<? x complex<f32>>):
  // CHECK: tfl.mul %arg0, %arg1 {fused_activation_function = "NONE"}
  %0 = tfl.mul %arg0, %arg1 {fused_activation_function = "NONE"}: tensor<? x complex<f32>>
  func.return %0#0 : tensor<? x complex<f32>>
}

// CHECK-LABEL: testAddWithI64Broadcasting

	}
}

type _Complex struct {
	a int
	b [3]*_Complex
	c *string
	d map[float64]float64
}

func TestDeepEqualComplexStruct(t *testing.T) {
	m := make(map[float64]float64)
	stra, strb := "hello", "hello"
	a, b := new(_Complex), new(_Complex)
	*a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
	*b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
	if !DeepEqual(a, b) {

	STT_LOPROC  SymType = 13 /* reserved range for processor */
	STT_HIPROC  SymType = 15 /*   specific semantics. */

	/* Non-standard symbol types. */
	STT_RELC      SymType = 8  /* Complex relocation expression. */
	STT_SRELC     SymType = 9  /* Signed complex relocation expression. */
	STT_GNU_IFUNC SymType = 10 /* Indirect code object. */
)

var sttStrings = []intName{
	{0, "STT_NOTYPE"},
	{1, "STT_OBJECT"},

		rt.Base.goString(indent+2, ""))
}

// ComplexType is a complex type.
type ComplexType struct {
	Base AST
}

func (ct *ComplexType) print(ps *printState) {
	printBase(ps, ct, ct.Base)
}

func (ct *ComplexType) printInner(ps *printState) {
	ps.writeString(" _Complex")
}

func (ct *ComplexType) Traverse(fn func(AST) bool) {
	if fn(ct) {

  func.return %0 : tensor<16xf32>
}

// -----

// Test tf.Min with complex numbers.
// Previous versions of tensorflow said complex numbers were allowed with
// tf.Min even though it doesn't make sense. The legalization of tf to xla
// requires that complex types are not allowed in tf.Min, so we have an
// explicit unit here to make sure that invariant is enforced.

		}},
		expectedNewlyActiveUDPServices: map[proxy.ServicePortName]bool{},
		expectedLocalEndpoints:         map[types.NamespacedName]int{},
	}, {
		// Case[13]: complex add and remove
		name:              "complex add and remove",
		previousEndpoints: complexBefore,
		currentEndpoints:  complexAfter,
		oldEndpoints: map[proxy.ServicePortName][]endpointExpectation{