}

//===----------------------------------------------------------------------===//
// ZerosLike
//===----------------------------------------------------------------------===//

// -----

// CHECK-LABEL: @zeros_like
// CHECK-SAME:  (%[[ARG:.*]]: tensor<2x?xf32>)
func.func @zeros_like(%arg0: tensor<2x?xf32>) -> tensor<2x?xf32> {

  auto gathered = Gather(scope, params, zero_clipped_indices);
  // Replace gathered params of negative indices with 0.
  auto zero_slice = ZerosLike(scope, gathered);
  return SelectV2(scope, is_positive, gathered, zero_slice);
}

Status UnsortedSegmentMinOrMaxGrad(const Scope& scope, const Operation& op,
                                   const std::vector<Output>& grad_inputs,

// gradients.
//
// `ZerosLike` is not expected to be called and returns a nullptr. The creation
// of default zeros grads is handled by the `DefaultGradientFunction` registered
// for each op.
// TODO(srbs): We need to define `ZerosLike` here to keep the compiler happy.
// Figure out a way to avoid this.
// TODO(srbs): Should ZerosLike check-fail instead of returning nullptr?
class TapeTensor {

  TF_RETURN_IF_ERROR(op_ptr->AddInputList(input));
  int num_retvals = output.size();
  return op_ptr->Execute(output, &num_retvals);
}

// Op: ZerosLike()
// Summary: Returns a tensor of zeros with the same shape and type as x.
//
// Description:
Status ZerosLike(AbstractContext* ctx, AbstractTensorHandle* const x,
                 AbstractTensorHandle** y, const char* name,
                 const char* raw_device_name) {

  --output_dir="${current_dir}" \
  --api_dirs="${api_dir}" \
  --source_dir=third_party/tensorflow"

${generate} \
  --category=array \
  Identity \
  IdentityN \
  ZerosLike \
  Shape \
  ExpandDims \
  OnesLike

${generate} \
  --category=math \
  Mul \
  Conj \
  AddV2 \
  MatMul \
  Neg \
  Sum \
  Sub \
  Div \
  DivNoNan \
  Exp \
  Sqrt \

  func.return
}

// CHECK-LABEL: func @variant
func.func @variant(%arg: tensor<!tf_type.variant>) {
  // CHECK: tf.ZerosLike
  // CHECK-SAME: T = !corert.variant
  %0 = "tf.ZerosLike"(%arg) {device = "/device:CPU:0", T = !tf_type.variant} : (tensor<!tf_type.variant>) -> tensor<!tf_type.variant>
  func.return
}

// Checks that TF quantized attrs are lowered to the corert types

                 const char* name = nullptr,
                 const char* raw_device_name = nullptr);

// Returns a tensor of zeros with the same shape and type as x.
Status ZerosLike(AbstractContext* ctx, AbstractTensorHandle* const x,
                 AbstractTensorHandle** y, const char* name = nullptr,
                 const char* raw_device_name = nullptr);

// Returns the shape of a tensor.

  }];

  let hasOptions = 1;
}

def TFL_ZerosLikeOp: TFL_Op<"zeros_like", [
    PredOpTrait<"input and output must have same element type",
      TFL_TCresVTEtIsSameAsOp<0, 0>>,
    SameOperandsAndResultShape,
    Pure]> {
  let summary = "ZerosLike operator";

  let description = [{
    Returns a tensor of zeros with the same shape and type as the input tensor.

int64_t ToId(const AbstractTensorHandle* t) {
  return static_cast<int64_t>(reinterpret_cast<uintptr_t>(t));
}

Status ZerosLike(AbstractContext* ctx, AbstractTensorHandle* t,
                 AbstractTensorHandle** result) {
  AbstractOperationPtr op(ctx->CreateOperation());
  TF_RETURN_IF_ERROR(op->Reset("ZerosLike", /*raw_device_name=*/nullptr));
  if (isa<tracing::TracingOperation>(op.get())) {

		{name: "E32", fn: func() { e = zero32 }},
		{name: "E64", fn: func() { e = zero64 }},
		{name: "Estr", fn: func() { e = zerostr }},
		{name: "Eslice", fn: func() { e = zeroslice }},
		{name: "Econstflt", fn: func() { e = 99.0 }}, // constants do not allocate
		{name: "Econststr", fn: func() { e = "change" }},
		{name: "I8", fn: func() { i1 = eight8I }},
		{name: "I16", fn: func() { i1 = zero16I }},