const ArrayRef<int64_t> output_dims) {
  if (other_tensor_zp == 0) {
    return CreateScalarConstValue<int32_t>(builder, loc, 0);
  }

  auto shape = mlir::cast<ShapedType>(tensor.getType());
  SmallVector<int64_t> non_output_indices;
  for (int64_t i : llvm::seq<int64_t>(0, shape.getRank())) {
    if (absl::c_count(output_dims, i) == 0) {
      non_output_indices.push_back(i);
    }
  }

  return tf_tensor;
}

TF_Tensor* TF_ForwardInputOrAllocateOutput(
    TF_OpKernelContext* context, const int* candidate_input_indices,
    int num_candidate_input_indices, int output_index,
    const int64_t* output_dims, int output_num_dims, int* forwarded_input,
    TF_Status* status) {
  TF_SetStatus(status, TF_OK, "");
  auto* cc_ctx = reinterpret_cast<::tensorflow::OpKernelContext*>(context);

           << output_dims[dnums.output_batch_dimension()]);
  output_dims[dnums.output_feature_dimension()] = kernel_output_feature;
  DCOMMENT("inferrd output output_feature_dimension is "
           << output_dims[dnums.output_feature_dimension()]);

  std::vector<int64_t> input_spatial_dims;
  llvm::SmallVector<int64_t> window_spatial_dims;
  for (auto i = 0; i < num_spatial_dims; ++i) {
    input_spatial_dims.push_back(

    TF_Status* s = TF_NewStatus();
    int candidate_input_indices[1] = {0};
    int forwarded_input;
    int64_t output_dims[1] = {};
    TF_Tensor* output = TF_ForwardInputOrAllocateOutput(
        /*context=*/ctx, candidate_input_indices,
        /*num_candidate_input_indices=*/1,
        /*output_index=*/0, output_dims, /*output_num_dims=*/0,
        &forwarded_input, /*status=*/s);
    EXPECT_EQ(TF_OK, TF_GetCode(s));

// -1.
TF_CAPI_EXPORT TF_Tensor* TF_ForwardInputOrAllocateOutput(
    TF_OpKernelContext* context, const int* candidate_input_indices,
    int num_candidate_input_indices, int output_index,
    const int64_t* output_dims, int output_num_dims, int* forwarded_input,
    TF_Status* status);

// Allocates a temporary Tensor of the specified type and shape. The
// Tensor must not be used after kernel construction is
// complete.
//

    std::iota(broadcast_dims.begin() + axis, broadcast_dims.end(), axis + 1);

    llvm::SmallVector<int64_t, 4> output_dims =
        llvm::to_vector<4>(indices_shape);
    output_dims.insert(output_dims.begin() + axis, depth);

    Location loc = op.getLoc();

    // The iota result is the effective output shape of the computation,

        tensorflow::Flag(
            "namespace", &name_space_,
            "Compact C++ namespace, default is 'tensorflow::ops'."),
        tensorflow::Flag(
            "output_dir", &output_dir_,
            "Directory into which output files will be generated."),
        tensorflow::Flag(
            "source_dir", &source_dir_,
            "The tensorflow root directory, e.g. 'tensorflow/' for "

        ImmutableSet.Builder<File> outputDirs = ImmutableSet.builderWithExpectedSize(3);
        MinimalJavaCompileOptions compileOptions = spec.getCompileOptions();
        addDirectoryIfNotNull(outputDirs, spec.getDestinationDir());
        addDirectoryIfNotNull(outputDirs, compileOptions.getAnnotationProcessorGeneratedSourcesDirectory());
        addDirectoryIfNotNull(outputDirs, compileOptions.getHeaderOutputDirectory());

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {

PathConfig::PathConfig(const string& output_dir, const string& source_dir,
                       const string& api_dir_list,
                       const std::vector<string> op_names)
    : output_path(output_dir), op_names(op_names) {
  api_dirs = str_util::Split(api_dir_list, ",", str_util::SkipEmpty());

        Map<String, ? extends File> outputDirs,
        Collection<? extends TestFile> create,

        InputFingerprinter inputFingerprinter,
        ExecutionHistoryStore executionHistoryStore
    ) {
        this.inputProperties = inputProperties
        this.inputFiles = inputFiles
        this.outputFiles = outputFiles
        this.outputDirs = outputDirs
        this.create = create