</tr>
            <tr>
                <td>displayName</td>
            </tr>
            <tr>
                <td>name</td>
            </tr>
            <tr>
                <td>outputType</td>
            </tr>
            <tr>
                <td>required</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>

    Property<? extends FileSystemLocation> getOutputLocation();

    /**
     * The type of output the report produces
     */
    enum OutputType {

        /**
         * The report outputs a single file.
         * <p>
         * That is, the {@link #getOutputLocation()} points to a single file.
         */
        FILE,

        /**

		return resultError("program instantiation failed: "+err.Error(), apiservercel.ErrorTypeInternal)
	}
	return CompilationResult{
		Program:            prog,
		ExpressionAccessor: expressionAccessor,
		OutputType:         ast.OutputType(),
	}
}

func mustBuildEnvs(baseEnv *environment.EnvSet) variableDeclEnvs {
	requestType := BuildRequestType()
	namespaceType := BuildNamespaceType()

 public:
  using OpRewritePattern<TF::HashTableV2Op>::OpRewritePattern;

  LogicalResult matchAndRewrite(TF::HashTableV2Op hashtable_op,
                                PatternRewriter& rewriter) const override {
    auto output_type = RankedTensorType::get(
        {1}, TF::ResourceType::get(rewriter.getContext()));

    // Hash the shared name to generate integer hash table id. The TFLite

                            custom_op.getCustomCode().str());
    op_state.addOperands(custom_op.getOperands());
    llvm::SmallVector<mlir::Type, 4> output_tys;
    for (int i = 0; i < custom_op.getNumResults(); i++) {
      output_tys.push_back(custom_op.getType(i));
    }
    op_state.addTypes(output_tys);
    op_state.addAttributes(attr);
    auto stablehlo_op = builder.create(op_state);
    custom_op.replaceAllUsesWith(stablehlo_op);

}

Status ConvertToTensorProto(const ElementsAttr attr, TensorProto* output) {
  auto type = attr.getShapedType();
  auto shape = type.getShape();
  DataType output_dtype;
  TF_RETURN_IF_ERROR(ConvertToDataType(type, &output_dtype));
  output->set_dtype(output_dtype);
  ConvertToTensorShapeProto(shape, output->mutable_tensor_shape());

  if (auto tensor_attr = mlir::dyn_cast<mlir::TF::TensorProtoAttr>(attr))

                                          n->def(), &input_mtypes,
                                          &output_mtypes));
    for (const Edge* e : n->out_edges()) {
      Node* dst = e->dst();

      if (e->IsControlEdge()) {
        continue;
      }

      bool edge_incurs_extra_device_to_host_copy;
      if (output_mtypes[e->src_output()] == DEVICE_MEMORY) {
        // If the output of the *TensorFlow* operation is in DEVICE_MEMORY then

        !bmm_op.getAdjY() ? create_z_x_transpose_op(input_rhs) : input_rhs;

    Type output_type = bmm_op.getResult().getType();
    auto no_input = rewriter.create<TFL::NoValueOp>(
        bmm_op->getLoc(), rewriter.getNoneType(), rewriter.getUnitAttr());
    auto fc_op = rewriter.create<TFL::FullyConnectedOp>(
        bmm_op->getLoc(), ArrayRef<Type>{output_type},
        /*input=*/output_lhs, /*filter=*/output_rhs, /*bias=*/no_input,

      crops_values.push_back(crops_value_int);
    }
  }

  auto output_type = mlir::cast<TensorType>(op.getOutput().getType());
  if (output_type.hasRank()) {
    if (output_type.getRank() != 4)
      return op.emitOpError()
             << "requires output to be a 4D tensor, but got " << output_type;

    auto static_dims = [](int64_t dim_a, int64_t dim_b) {

import java.io.File;

public abstract class TaskGeneratedSingleFileReport extends TaskGeneratedReport implements SingleFileReport {
    @Inject
    public TaskGeneratedSingleFileReport(String name, Task task) {
        super(name, OutputType.FILE, task);
        // This is for backwards compatibility for plugins that attach a convention mapping to the replaced property
        // TODO - this wiring should happen automatically (and be deprecated too)