}
  }
  attr {
    key: "index_type"
    value {
      type: DT_INT32
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "gradients/foo_grad/SymbolicGradient"
  op: "SymbolicGradient"
  input: "Const"
  input: "gradients/Fill"
  attr {
    key: "Tin"
    value {
      list {
        type: DT_FLOAT
        type: DT_FLOAT
      }
    }
  }
  attr {

    input_dtypes.push_back(op.input_type(i));
  }

  func_inputs.insert(std::end(func_inputs), std::begin(grad_inputs),
                     std::end(grad_inputs));

  auto grad = SymbolicGradient(scope, func_inputs, input_dtypes, f);
  for (int i = 0; i < num_inputs; i++) {
    grad_outputs->push_back(grad[i]);
  }

  return scope.status();
}

  TF_ASSERT_OK(root.graph()->AddFunctionLibrary(flib_def));

  Node* read = MakeRead(root, "R");
  NameAttrList fn;
  fn.set_name("Const_func");
  Node* symbolic_gradient =
      ops::SymbolicGradient(root, /*input=*/{ops::Const(root, 1.0f)},
                            /*Tout=*/{DT_FLOAT}, fn)
          .output[0]
          .node();

  root.graph()->AddControlEdge(symbolic_gradient, read);

    const Node& node, string* uncompilable_reason) const {
  // There is a SymbolicGradient kernel on the XLA_JIT device, but the gradient
  // is really a kind of function call and will be handled by
  // IsCompilableCall().
  if (node.type_string() == "SymbolicGradient") {
    *uncompilable_reason =
        "SymbolicGradient should be handled by IsCompilableCall().";
    return false;
  }

    Node* a =
        ops::SourceOp("UncompilableNullary", builder.opts().WithName("A"));

    // Builds a Symbolic gradient for Supported
    NodeBuilder b_builder("B", "SymbolicGradient",
                          builder.opts().op_registry());
    NameAttrList b_name_attr;
    b_name_attr.set_name("Supported");
    b_builder.Attr("f", b_name_attr);
    b_builder.Attr("Tin", {DT_FLOAT, DT_FLOAT});

      "StatelessRandomUniformFullIntV2",
      "StatelessTruncatedNormal",
      "StatelessTruncatedNormalV2",
      "StatelessWhile",
      "StochasticCastToInt",
      "Svd",
      "SymbolicGradient",
      "TensorArrayCloseV3",
      "TensorArrayConcatV3",
      "TensorArrayGatherV3",
      "TensorArrayGradV3",
      "TensorArrayReadV3",
      "TensorArrayScatterV3",
      "TensorArraySizeV3",

Undefined if `compute_uv` is false.}]>:$v
  );

  TF_DerivedOperandTypeAttr T = TF_DerivedOperandTypeAttr<0>;
}

def TF_SymbolicGradientOp : TF_Op<"SymbolicGradient", [Pure]> {
  let summary = [{
Computes the gradient function for function f via backpropagation.
  }];

  let arguments = (ins