check(gen(10), 10)

	check(add(gen(3), zero()), 3)
	check(add(zero(), gen(4)), 4)
	check(add(gen(3), gen(4)), 7)

	check(mul(zero(), zero()), 0)
	check(mul(gen(3), zero()), 0)
	check(mul(zero(), gen(4)), 0)
	check(mul(gen(3), add1(zero())), 3)
	check(mul(add1(zero()), gen(4)), 4)
	check(mul(gen(3), gen(4)), 12)

	check(fact(zero()), 1)
	check(fact(add1(zero())), 1)
	check(fact(gen(5)), 120)
}

    // CHECK: [[ACCUM_MOMENTUM:%.*]] = "tf.Mul"([[ACCUM]], [[MOMENTUM]])
    // CHECK: [[ACCUM_NEW:%.*]] = "tf.AddV2"([[ACCUM_MOMENTUM]], [[GRAD]])
    // CHECK: "tf.AssignVariableOp"([[ACCUM_HANDLE]], [[ACCUM_NEW]])
    // CHECK: [[GRAD_LR:%.*]] = "tf.Mul"([[GRAD]], [[LR]])
    // CHECK: [[MOMENTUM_LR:%.*]] = "tf.Mul"([[MOMENTUM]], [[LR]])
    // CHECK: [[ACCUM_NEW_MOMENTUM_LR:%.*]] = "tf.Mul"([[ACCUM_NEW]], [[MOMENTUM_LR]])

  // CHECK: %[[MUL:.*]] = tfl.mul
  %2 = "tfl.mul"(%0, %1) {fused_activation_function = "NONE"} : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> loc("mul")
  // CHECK: %[[DIV:.*]] = tfl.div
  %3 = "tfl.div"(%2, %1) {fused_activation_function = "NONE"} : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> loc("div")
  // CHECK: %[[EXP:.*]] = "tfl.exp"

        %cast = "tf.Cast"(%output) : (tensor<1024x24x24x3xi32>) -> tensor<1024x24x24x3xf32>
        %mul = "tf.Mul"(%cast, %scale) : (tensor<1024x24x24x3xf32>, tensor<f32>) -> tensor<1024x24x24x3xf32>
        func.return %mul : tensor<1024x24x24x3xf32>
      }
    }
  )mlir";

  OwningOpRef<ModuleOp> module_op_ref = ParseModuleOpString(kModuleCode);
  const auto test_func =

    value {
      type: DT_INT32
    }
  }
}
node {
  name: "Mul"
  op: "Mul"
  input: "Add"
  input: "Add"
  # Empty device name should be kept untouched.
  device: ""
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
}
node {
  name: "Sub"
  op: "Sub"
  input: "Add"
  input: "Mul"
  # Device name is not modified if complete

}

func nextTerm(k int64) {
	y2 := k*2 + 1
	accum.Add(accum, tmp1.Lsh(numer, 1))
	accum.Mul(accum, tmp1.SetInt64(y2))
	numer.Mul(numer, tmp1.SetInt64(k))
	denom.Mul(denom, tmp1.SetInt64(y2))
}

func eliminateDigit(d int64) {
	accum.Sub(accum, tmp1.Mul(denom, tmp1.SetInt64(d)))
	accum.Mul(accum, ten)
	numer.Mul(numer, ten)
}

func main() {
	i := 0
	k := int64(0)
	for {
		d := int64(-1)
		for d < 0 {

  EXPECT_EQ(child.GetUniqueNameForOp("add"), "child/add_1");
  EXPECT_EQ(child.GetUniqueNameForOp("mul"), "child/mul");

  Scope child_1 = root.NewSubScope("child");
  EXPECT_EQ(child_1.GetUniqueNameForOp("add"), "child_1/add");
  EXPECT_EQ(child_1.GetUniqueNameForOp("add"), "child_1/add_1");
  EXPECT_EQ(child_1.GetUniqueNameForOp("mul"), "child_1/mul");

  Scope c_c = root.NewSubScope("c").NewSubScope("c");

                        ZerosLike(scope, x));
    auto gy_1 = Mul(scope, Mul(scope, grad, z), log_x);
    return BinaryGradCommon(scope, op, grad_outputs, gx_1, gy_1);
  } else {
    // There's no sensible real value to return if x < 0, so return 0
    auto log_x = Where3(scope, Greater(scope, x, zero), Log(scope, x),
                        ZerosLike(scope, x));
    auto gy_1 = Mul(scope, Mul(scope, grad, z), log_x);

	t0 := new(fiat.P224Element).Mul(p1.x, p2.x)  // t0 := X1 * X2
	t1 := new(fiat.P224Element).Mul(p1.y, p2.y)  // t1 := Y1 * Y2
	t2 := new(fiat.P224Element).Mul(p1.z, p2.z)  // t2 := Z1 * Z2
	t3 := new(fiat.P224Element).Add(p1.x, p1.y)  // t3 := X1 + Y1
	t4 := new(fiat.P224Element).Add(p2.x, p2.y)  // t4 := X2 + Y2
	t3.Mul(t3, t4)                               // t3 := t3 * t4

	t0 := new(fiat.P521Element).Mul(p1.x, p2.x)  // t0 := X1 * X2
	t1 := new(fiat.P521Element).Mul(p1.y, p2.y)  // t1 := Y1 * Y2
	t2 := new(fiat.P521Element).Mul(p1.z, p2.z)  // t2 := Z1 * Z2
	t3 := new(fiat.P521Element).Add(p1.x, p1.y)  // t3 := X1 + Y1
	t4 := new(fiat.P521Element).Add(p2.x, p2.y)  // t4 := X2 + Y2
	t3.Mul(t3, t4)                               // t3 := t3 * t4