WhileRegionOp CreateDatasetWhile(OpBuilder builder,
                                 ReduceDatasetOp reduce_dataset) {
  auto const_true = builder.create<TF::ConstOp>(
      reduce_dataset.getLoc(),
      DenseIntElementsAttr::get(
          RankedTensorType::get(/*shape=*/{}, builder.getI1Type()), true));

  SmallVector<Value, 4> while_input_values;
  SmallVector<Type, 4> while_input_types;

}

// Generate a dummy constant island of requested type.
IslandOp GetDummyConstant(OpBuilder builder, ShapedType const_type,
                          Location loc) {
  DenseIntElementsAttr val = DenseIntElementsAttr::get(const_type, 1);
  auto const_op = builder.create<TF::ConstOp>(loc, val);
  auto const_island = CreateIsland(const_op, {}, builder);
  return const_island;
}

    Operation *tposed_const;
    if (other_input_type.getNumElements() == 1) {
      tposed_const = cst_arg;
    } else {
      auto inverse_perm_attr = DenseIntElementsAttr::get(
          RankedTensorType::get(inverse_perm.size(), rewriter.getI32Type()),
          inverse_perm);
      auto inverse_perm_op =
          rewriter.create<arith::ConstantOp>(perm.getLoc(), inverse_perm_attr);

namespace mlir {
namespace TF {
namespace collection_ops_util {

Value CreateScalarConst(int32_t value, OpBuilder builder, Location loc) {
  auto attr = DenseIntElementsAttr::get(
      tensorflow::GetTypeFromTFTensorShape({}, builder.getI32Type()), value);
  return builder.create<TF::ConstOp>(loc, attr);
}

Value GetR1Const(ArrayRef<int64_t> r1, OpBuilder builder, Location loc,

                                  op)))
        return failure();

      OpBuilder builder(op);
      auto const_op = builder.create<TF::ConstOp>(
          op->getLoc(), DenseIntElementsAttr::get(
                            RankedTensorType::get({}, builder.getI64Type()),
                            {device_ordinal}));
      op->replaceAllUsesWith(const_op);
      op->erase();

        return transpose_op.emitOpError(
            "perm tensor elements size is not equal to input tensor rank");
      }
    }

    // Get permutation axes of the TransposeOp
    DenseIntElementsAttr perm;
    if (!matchPattern(transpose_op.getPerm(), m_Constant(&perm))) {
      return failure();
    }

    SmallVector<int64_t, 4> axes;
    for (const auto& axis_int : perm.getValues<APInt>()) {

      mlir::TensorType ty =
          mlir::RankedTensorType::get(vals.size(), builder.getIntegerType(64));
      TensorProto tensor;
      TF_RETURN_IF_ERROR(ConvertToTensorProto(
          mlir::DenseIntElementsAttr::get(ty, vals), &tensor));
      *list->add_tensor() = tensor;
    } else {
      return errors::Unimplemented("Unhandled attribute!");
    }
  }
  return absl::OkStatus();
}

                               OpBuilder* builder) {
  auto type =
      mlir::RankedTensorType::get(value.size(), builder->getIntegerType(32));
  auto dense_values = mlir::DenseIntElementsAttr::get(type, value);
  return builder->create<TF::ConstOp>(loc, dense_values);
}

TF::ConstOp CreateScalarConstantOp(int value, Location loc,
                                   OpBuilder* builder) {