dot_dimension_nums.getRhsContractingDimensions();
    const auto lhs_contracting_dims =
        dot_dimension_nums.getLhsContractingDimensions();

    const Value rhs_value = op.getRhs();
    const Value lhs_value = op.getLhs();

    Operation* rhs_op = rhs_value.getDefiningOp();
    auto filter_constant_op = dyn_cast_or_null<stablehlo::ConstantOp>(rhs_op);

    // Set to `nullptr` because this attribute only matters when the input is

  if (lhs && lhs.isSplat()) {
    APFloat lhs_value = lhs.getSplatValue<APFloat>();
    lhs_value.changeSign();
    if (lhs_value.isLargest()) return getRhs();
  }
  if (rhs && rhs.isSplat()) {
    APFloat rhs_value = rhs.getSplatValue<APFloat>();
    rhs_value.changeSign();
    if (rhs_value.isLargest()) return getLhs();
  }
  return nullptr;
}

}

// Returns true if `value` is compile-time constant and its splat value equals
// to `raw_value`.
template <typename T>
bool IsConstantValueOf(mlir::TypedAttr value, T raw_value) {
  auto element_type = mlir::cast<ShapedType>(value.getType()).getElementType();

  if (mlir::isa<FloatType>(element_type)) {
    return FloatValueEquals(value, raw_value);
  } else if (mlir::isa<IntegerType>(element_type)) {

  int32_t input_spatial_dims =
      static_cast<int32_t>(dnums.getInputSpatialDimensions().size());
  if (!conv_op.getWindowStrides().has_value()) {
    conv_op.setWindowStridesAttr(
        rewriter.getI64TensorAttr(std::vector<int64_t>(input_spatial_dims, 1)));
  }
  if (!conv_op.getPadding().has_value()) {
    conv_op.setPaddingAttr(DenseIntElementsAttr::get(
        RankedTensorType::get({input_spatial_dims, 2}, rewriter.getI64Type()),

  ValueType delta = delta_attr.getValue();

  SmallVector<ValueType, 16> new_values;
  new_values.reserve(num_elements);
  ValueType new_value = start;
  for (int i = 0; i < num_elements; ++i) {
    new_values.push_back(new_value);
    new_value = new_value + delta;
  }
  // Result is always a 1-D tensor.
  auto new_result_type =
      tensorflow::GetTypeFromTFTensorShape({num_elements}, result_elem_type);

  std::string op_name = tflite::EnumNamesBuiltinOperator()[op_code];
  std::string graph_name = op_name + std::to_string(subgraph_index);
  auto subgraph = BuildSubGraph(graph_name, region, subgraph_index);
  if (!subgraph.has_value()) {
    mlir::emitError(region->getLoc(), "failed to build subgraph");
    return -1;
  }
  subgraphs_.push_back(subgraph.value());
  subgraph_index_map_[graph_name] = subgraph_index;

      exceptions.size())
    return failure();

  // Compute binary operands hoist parameters.
  auto hoist_params = GetHoistParams(op, axis, exceptions);
  if (!hoist_params.has_value()) return failure();

  // Process `exceptions`: For each value there, synthesize a binary op of the
  // above kind, so that the concat hoisting optimization can still apply.
  if (!exceptions.empty()) {

      tensorflow::EvaluateConstantTensorRunner{
          graph->graph.op_registry(),
          graph->graph.versions().producer(),
      });
  if (!status_or.ok() || !status_or->has_value()) {
    *result = nullptr;
    status->status = std::move(status_or).status();
    return false;
  }
  *result = TF_TensorFromTensor(**status_or, &status->status);
  return status->status.ok();
}

                     input_.meta_graph_def().graph_def().versions());

  llvm::DenseSet<llvm::StringRef> exported_name_set;
  bool import_all_signatures = !exported_names_.has_value();
  if (exported_names_.has_value()) {
    exported_name_set.insert(exported_names_->begin(), exported_names_->end());
  }

  absl::Mutex error_status_mu;  // Needed since `error_status` is non-atomic.

         !IsSupportedNonTFOp(use.getOwner());
}

TensorType CreateTensorType(std::optional<llvm::ArrayRef<int64_t>> shape,
                            Type element_type) {
  if (shape.has_value())
    return tensorflow::GetTypeFromTFTensorShape(shape.value(), element_type);
  return UnrankedTensorType::get(element_type);
}

// Returns true if the op creates a TensorList.