diff --git a/mlir-tensorrt/.gitignore b/mlir-tensorrt/.gitignore
index e410819ad..b6a2e4a6c 100644
--- a/mlir-tensorrt/.gitignore
+++ b/mlir-tensorrt/.gitignore
@@ -32,6 +32,8 @@ compile_commands.json
 **/*.private.*
 *.private
 **/tmp/**
+**/tmp**
+**/tripy/**
 
 # TRT Timing Cache artifacts
 *.timing-cache
diff --git a/mlir-tensorrt/compiler/include/mlir-tensorrt/Dialect/Plan/IR/PlanOps.td b/mlir-tensorrt/compiler/include/mlir-tensorrt/Dialect/Plan/IR/PlanOps.td
index a1a7f1137..6d2077864 100644
--- a/mlir-tensorrt/compiler/include/mlir-tensorrt/Dialect/Plan/IR/PlanOps.td
+++ b/mlir-tensorrt/compiler/include/mlir-tensorrt/Dialect/Plan/IR/PlanOps.td
@@ -7,7 +7,6 @@ include "mlir-tensorrt-dialect/Interface/TensorKindOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/DestinationStyleOpInterface.td"
-include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/IR/OpAsmInterface.td"
 
 class Plan_NativeOpTrait<string name,
@@ -136,8 +135,6 @@ def Plan_InlineGroupOp : Plan_GroupOpBase<"inline_group", [
 
 def Plan_InlineClosedGroupOp : Plan_GroupOpBase<"inline_closed_group", [
   IsolatedFromAbove,
-  AttrSizedOperandSegments,
-  DestinationStyleOpInterface,
   SingleBlockImplicitTerminator<"plan::YieldOp">,
   DeclareOpInterfaceMethods<RegionBranchOpInterface,
     ["getEntrySuccessorOperands"]>,
@@ -199,9 +196,7 @@ def Plan_InlineClosedGroupOp : Plan_GroupOpBase<"inline_closed_group", [
 
   }];
   let arguments = (ins Variadic<AnyTypeOf<[AnyRankedTensor, AnySignlessIntegerOrIndex]>>:$inputs,
-                       Variadic<AnyRankedTensor>:$outs,
                        BoundsAttrArray:$input_attrs,
-                       BoundsAttrArray:$res_attrs,
                        AnyAttr:$target);
 
   let results = (outs Variadic<AnyType>:$results);
@@ -209,9 +204,8 @@ def Plan_InlineClosedGroupOp : Plan_GroupOpBase<"inline_closed_group", [
   let assemblyFormat = [{
     `target` `(` $target `)` `\n`
     `inputs` `(` ( $inputs^ `:` type($inputs) `)` ) : ( `)` ) ?  `\n`
-    `outs` `(` $outs `:` type($outs) `)` `\n`
     `in_attrs` $input_attrs `\n`
-    `res_attrs` $res_attrs attr-dict-with-keyword `->` type($results)
+     attr-dict-with-keyword `->` type($results)
      $body
   }];
 
@@ -220,18 +214,14 @@ def Plan_InlineClosedGroupOp : Plan_GroupOpBase<"inline_closed_group", [
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilder<(ins "Attribute":$target,
-                   "ValueRange":$inputs, "ValueRange":$outs,
-                   CArg<"ArrayRef<BoundsAttr>", "{}">:$input_attrs,
-                   CArg<"ArrayRef<BoundsAttr>", "{}">:$res_attrs)>
+    OpBuilder<(ins "TypeRange":$results,
+                   "Attribute":$target,
+                   "ValueRange":$inputs,
+                   CArg<"ArrayRef<BoundsAttr>", "{}">:$input_attrs)>
   ];
 
   let extraClassDeclaration = baseExtraClassDeclaration # [{
 
-    MutableOperandRange getDpsInitsMutable() {
-      return getOutsMutable();
-    }
-
     /// Returns true if the `i-th` input argument has a tensor type.
     bool argHasTensorType(unsigned inputIdx) {
       assert(inputIdx < getInputs().size() && "input index out-of-bounds");
@@ -244,17 +234,6 @@ def Plan_InlineClosedGroupOp : Plan_GroupOpBase<"inline_closed_group", [
       return cast<BoundsAttr>(getInputAttrs()[inputIdx]);
     }
 
-    ArrayRef<BlockArgument> getRegionOutArgs() {
-      return getBody().getArguments().take_back(getOuts().size());
-    }
-
-    /// Populate the `res_attrs` from an array of BoundsAttrs.
-    void setResAttrsAttr(ArrayRef<BoundsAttr> boundsAttrs) {
-      setResAttrsAttr(::mlir::ArrayAttr::get(
-        getOperation()->getContext(),
-        ArrayRef<Attribute>(boundsAttrs.begin(), boundsAttrs.end())
-      ));
-    }
 
     /// Populate the `input_attrs` from an array of BoundsAttrs.
     void setInputAttrsAttr(ArrayRef<BoundsAttr> boundsAttrs) {
diff --git a/mlir-tensorrt/compiler/include/mlir-tensorrt/Dialect/TensorRTRuntime/IR/TensorRTRuntimeOps.td b/mlir-tensorrt/compiler/include/mlir-tensorrt/Dialect/TensorRTRuntime/IR/TensorRTRuntimeOps.td
index 23343faa4..ef825e36e 100644
--- a/mlir-tensorrt/compiler/include/mlir-tensorrt/Dialect/TensorRTRuntime/IR/TensorRTRuntimeOps.td
+++ b/mlir-tensorrt/compiler/include/mlir-tensorrt/Dialect/TensorRTRuntime/IR/TensorRTRuntimeOps.td
@@ -7,9 +7,10 @@ include "mlir-tensorrt/Dialect/CUDA/IR/CUDATypes.td"
 include "mlir-tensorrt-dialect/Interface/TensorKindOpInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/IR/RegionKindInterface.td"
-include "mlir/Interfaces/DestinationStyleOpInterface.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
+include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.td"
+
 
 
 def TensorRTRuntime_TensorRTRuntimeOpTrait: NativeOpTrait<"TensorRTRuntimeOpTrait"> {
@@ -61,11 +62,8 @@ def TensorRTRuntime_CompileOp : TensorRTRuntime_Op<"compile", [Pure]> {
 //===----------------------------------------------------------------------===//
 
 def TensorRTRuntime_EnqueueOp : TensorRTRuntime_Op<"enqueue", [
-    DeclareOpInterfaceMethods<InferTypeOpInterface>,
     DeclareOpInterfaceMethods<TensorKindOpInterface>,
     DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
-    AttrSizedOperandSegments,
-    DestinationStyleOpInterface
 ]> {
   let description = [{
 
@@ -88,23 +86,19 @@ def TensorRTRuntime_EnqueueOp : TensorRTRuntime_Op<"enqueue", [
   let arguments = (ins TensorRTRuntime_Context:$execution_context,
                        CUDA_Stream:$stream,
                        Variadic<AnyShaped>:$inputs,
-                       Variadic<AnyShaped>:$outs,
                        OptionalAttr<DenseI64ArrayAttr>:$host_tensor_args);
   let results = (outs Variadic<AnyType>:$results);
 
   let assemblyFormat = [{
     $execution_context `stream` `(` $stream `)` ` `
     (`host_tensor_args` $host_tensor_args^ ` ` )?
-    `(` $inputs `)` `outs` `(` $outs `)`
-    attr-dict `:` functional-type($inputs, $outs)
+    `(` $inputs `)`
+    attr-dict `:` functional-type($inputs, $results)
   }];
 
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
-    // Declare the outs as inits/outs to DestinationStyleOpInterface.
-    MutableOperandRange getDpsInitsMutable() { return getOutsMutable(); }
-
     /// Return true if the operand at the specified index is a host tensor
     /// argument.
     bool isOperandOnHost(int64_t operandIdx) {
diff --git a/mlir-tensorrt/compiler/lib/Conversion/TensorRTRuntimeToExecutor/TensorRTRuntimeToExecutor.cpp b/mlir-tensorrt/compiler/lib/Conversion/TensorRTRuntimeToExecutor/TensorRTRuntimeToExecutor.cpp
index d246c7338..730252cc4 100644
--- a/mlir-tensorrt/compiler/lib/Conversion/TensorRTRuntimeToExecutor/TensorRTRuntimeToExecutor.cpp
+++ b/mlir-tensorrt/compiler/lib/Conversion/TensorRTRuntimeToExecutor/TensorRTRuntimeToExecutor.cpp
@@ -25,6 +25,7 @@
 #include "mlir-tensorrt/Dialect/CUDA/IR/CUDADialect.h"
 #include "mlir-tensorrt/Dialect/TensorRTRuntime/IR/TensorRTRuntime.h"
 #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
+#include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/TypeUtilities.h"
@@ -41,6 +42,9 @@ using namespace mlir;
 using namespace mlir::executor;
 using namespace mlir::cuda;
 
+static ExecutorOpaqueType getTrtOutputsOpaqueType(MLIRContext *ctx) {
+  return ExecutorOpaqueType::get(ctx, "trtrt_outputs");
+}
 static ExecutorOpaqueType getTrtRuntimeOpaqueType(MLIRContext *ctx) {
   return ExecutorOpaqueType::get(ctx, "trtrt_runtime");
 }
@@ -184,8 +188,6 @@ struct ConvertEnqueueToCall
     std::string funcName;
     funcName =
         "_" + llvm::join(llvm::split(op->getName().getStringRef(), "."), "_");
-    if (op->getNumResults() > 0)
-      return failure();
 
     SmallVector<Value> newOperands = {adaptor.getExecutionContext(),
                                       adaptor.getStream()};
@@ -217,10 +219,6 @@ struct ConvertEnqueueToCall
       if (failed(createMemRefAndExractPtr(oldVal, newVal)))
         return failure();
     }
-    for (auto [oldVal, newVal] : llvm::zip(op.getOuts(), adaptor.getOuts())) {
-      if (failed(createMemRefAndExractPtr(oldVal, newVal)))
-        return failure();
-    }
 
     // Create the table containing the pointer/offset args and append it to the
     // arguments for the call op.
@@ -230,21 +228,39 @@ struct ConvertEnqueueToCall
         argTablePack);
     newOperands.push_back(args);
 
+    SmallVector<Type, 4> resultTypes(op->getResultTypes().begin(), op->getResultTypes().end());
+
     auto parentModule = op->getParentOfType<ModuleOp>();
     auto enqueueFunc = getOrInsertFuncDeclaration(
         rewriter, op.getLoc(), parentModule, funcName,
         ExecutorFunctionType::get(rewriter.getContext(),
                                   {adaptor.getExecutionContext().getType(),
                                    adaptor.getStream().getType()},
-                                  {}, rewriter.getUnitAttr()));
+                                  resultTypes, rewriter.getUnitAttr()));
 
     rewriter.replaceOpWithNewOp<CallOp>(
-        op, TypeRange{}, enqueueFunc.getLeafReference(), newOperands);
+        op, op->getResultTypes(), enqueueFunc.getLeafReference(), newOperands);
 
     return success();
   }
 };
 
+class RemoveBufferizationClonePattern : public OpRewritePattern<bufferization::CloneOp> {
+public:
+  using OpRewritePattern::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(bufferization::CloneOp op,
+                                PatternRewriter &rewriter) const override {
+    // Replace all uses of the clone op with its input
+    rewriter.replaceAllUsesWith(op.getResult(), op.getInput());
+    
+    // Erase the clone op
+    rewriter.eraseOp(op);
+    
+    return success();
+  }
+};
+
 struct ConvertTrtrtOpToCall : public ConvertToExecutorPattern {
   ConvertTrtrtOpToCall(ExecutorTypeConverter &typeConverter,
                        MLIRContext *context, PatternBenefit benefit = 1)
@@ -282,6 +298,11 @@ struct ConvertTrtrtOpToCall : public ConvertToExecutorPattern {
   }
 };
 
+void populateRemoveBufferizationClonePatterns(RewritePatternSet &patterns) {
+  patterns.add<RemoveBufferizationClonePattern>(patterns.getContext());
+}
+
+
 } // namespace
 
 namespace {
@@ -320,6 +341,7 @@ class TensorRTRuntimeToExecutorPass
     typeConverter.addConversion([](cuda::StreamType t) {
       return getCudaStreamOpaqueType(t.getContext());
     });
+
     // Convert `trtrt.compile` to globals that create execution context from
     // serialized TensorRT engine data.
     {
@@ -335,6 +357,15 @@ class TensorRTRuntimeToExecutorPass
         return signalPassFailure();
     }
 
+    {
+      RewritePatternSet patterns(&getContext());
+      populateRemoveBufferizationClonePatterns(patterns);
+
+      if (failed(applyPatternsAndFoldGreedily(getOperation(),
+                                        std::move(patterns))))
+        return signalPassFailure();
+    }
+
     // Convert `trtrt.enqueue|create_runtime|execution_context|load` to
     // `executor.call` and function declarations.
     {
diff --git a/mlir-tensorrt/compiler/lib/Conversion/TensorRTToTensorRTRuntime/TensorRTToTensorRTRuntime.cpp b/mlir-tensorrt/compiler/lib/Conversion/TensorRTToTensorRTRuntime/TensorRTToTensorRTRuntime.cpp
index cc4cc2c14..d1d8f4e4f 100644
--- a/mlir-tensorrt/compiler/lib/Conversion/TensorRTToTensorRTRuntime/TensorRTToTensorRTRuntime.cpp
+++ b/mlir-tensorrt/compiler/lib/Conversion/TensorRTToTensorRTRuntime/TensorRTToTensorRTRuntime.cpp
@@ -35,6 +35,11 @@
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+#include "llvm/Support/Debug.h"
+
+#define DEBUG_TYPE "tensorrt-to-tensorrt-runtime"
+#define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE "] ")
+
 namespace mlir {
 #define GEN_PASS_DEF_CONVERTTENSORRTTOTENSORRTRUNTIMEPASS
 #include "mlir-tensorrt/Conversion/Passes.h.inc"
@@ -123,12 +128,15 @@ class ConvertTensorRTToRuntimePass
                    {FlatSymbolRefAttr::get(trtFunc)}));
       Value stream = rewriter.create<cuda::GetGlobalStreamOp>(loc, 0);
       auto enqueueOp = rewriter.create<trtrt::EnqueueOp>(
-          loc, executionContext, stream, callOp.getInputs(),
-          callOp.getOutputs(),
+          loc, callOp->getResultTypes(), executionContext, stream, callOp.getInputs(),
           /*host_tensors_args=*/hostTensorArgs.empty()
               ? DenseI64ArrayAttr{}
               : DenseI64ArrayAttr::get(ctx, hostTensorArgs));
       rewriter.setInsertionPointAfter(enqueueOp);
+
+      DBGS() << "Number of call op results: " << callOp->getNumResults() << "\n"; 
+      DBGS() << "Number of enqueue op results: " << enqueueOp->getNumResults() << "\n"; 
+
       rewriter.replaceOp(callOp, enqueueOp->getResults());
     }
   }
diff --git a/mlir-tensorrt/compiler/lib/Dialect/Plan/IR/PlanOps.cpp b/mlir-tensorrt/compiler/lib/Dialect/Plan/IR/PlanOps.cpp
index 153805421..5f6aaf58e 100644
--- a/mlir-tensorrt/compiler/lib/Dialect/Plan/IR/PlanOps.cpp
+++ b/mlir-tensorrt/compiler/lib/Dialect/Plan/IR/PlanOps.cpp
@@ -387,21 +387,6 @@ LogicalResult InlineClosedGroupOp::verify() {
       return failure();
   }
 
-  SmallVector<BoundsAttr> resAttrs =
-      llvm::to_vector(getResAttrs().getAsRange<BoundsAttr>());
-  if (resAttrs.size() != getNumResults())
-    return emitOpError("expected number of results (")
-           << getNumResults()
-           << ") to equal the number of res_attrs BoundsAttrs ("
-           << resAttrs.size() << ")";
-
-  for (auto [idx, type] : llvm::enumerate(getResultTypes())) {
-    BoundsAttr boundsAttr = resAttrs[idx];
-    if (failed(verifyBoundsAttr("result", idx, type, boundsAttr,
-                                [&]() { return emitOpError(); })))
-      return failure();
-  }
-
   return success();
 }
 
@@ -424,33 +409,22 @@ InlineClosedGroupOp::getEntrySuccessorOperands(RegionBranchPoint point) {
 
 void InlineClosedGroupOp::getAsmBlockArgumentNames(
     Region &region, OpAsmSetValueNameFn setNameFn) {
-  assert(region.front().getNumArguments() ==
-             getInputs().size() + getOuts().size() &&
-         "expected one block arg for each input and destination argument");
-  unsigned numInputs = getInputs().size();
+  assert(region.front().getNumArguments() == getInputs().size() &&
+         "expected one block arg for each input argument");
   for (BlockArgument arg : region.front().getArguments()) {
-    StringRef name = arg.getArgNumber() < numInputs ? "in" : "out";
-    setNameFn(arg, name);
+    setNameFn(arg, "in");
   }
 }
 
 void InlineClosedGroupOp::build(OpBuilder &b, OperationState &state,
-                                Attribute target, ValueRange inputs,
-                                ValueRange outs,
-                                ArrayRef<BoundsAttr> input_attrs,
-                                ArrayRef<BoundsAttr> result_attrs) {
+                                TypeRange resultTypes, Attribute target,
+                                ValueRange inputs,
+                                ArrayRef<BoundsAttr> input_attrs) {
+  state.addTypes(resultTypes);
   state.addOperands(inputs);
-  state.addOperands(outs);
   state.getOrAddProperties<Properties>().target = target;
   state.getOrAddProperties<Properties>().setInputAttrs(b.getArrayAttr(
       SmallVector<Attribute>(input_attrs.begin(), input_attrs.end())));
-  state.getOrAddProperties<Properties>().setResAttrs(b.getArrayAttr(
-      SmallVector<Attribute>(result_attrs.begin(), result_attrs.end())));
-
-  llvm::copy(
-      ArrayRef<int32_t>{static_cast<int32_t>(inputs.size()),
-                        static_cast<int32_t>(outs.size())},
-      state.getOrAddProperties<Properties>().operandSegmentSizes.begin());
   Region *body = state.addRegion();
   auto getLocs = [](ValueRange r) {
     SmallVector<Location> locs;
@@ -461,8 +435,6 @@ void InlineClosedGroupOp::build(OpBuilder &b, OperationState &state,
   };
   (void)body->emplaceBlock();
   body->addArguments(TypeRange(inputs), getLocs(inputs));
-  body->addArguments(TypeRange(outs), getLocs(outs));
-  state.addTypes(TypeRange(outs));
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/AllocTensors.cpp b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/AllocTensors.cpp
index 96a719ade..bbe219353 100644
--- a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/AllocTensors.cpp
+++ b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/AllocTensors.cpp
@@ -854,10 +854,10 @@ class AllocTensorsPass
 
     // First rewrite public functions to conform to DPS style.
     IRRewriter rewriter(ctx);
-    if (failed(rewriteNotPrivateFuncsToDPS(rewriter, op))) {
-      op->emitError("Failed to convert non-private functions to DPS");
-      return signalPassFailure();
-    }
+    // if (failed(rewriteNotPrivateFuncsToDPS(rewriter, op))) {
+    //   op->emitError("Failed to convert non-private functions to DPS");
+    //   return signalPassFailure();
+    // }
 
     // Rewrite SCF for and while loop bodies for better bufferization results,
     // if possible.
diff --git a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/CreateClosedRegions.cpp b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/CreateClosedRegions.cpp
index f939940cd..33044f431 100644
--- a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/CreateClosedRegions.cpp
+++ b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/CreateClosedRegions.cpp
@@ -120,10 +120,8 @@ enum class DestinationOperandMaterializationStrategy {
 };
 
 struct DestinationOperandMaterializationResult {
-  DestinationOperandMaterializationStrategy strategy;
   Value destinationOperand;
   /// The exact shape of the output.
-  std::optional<SmallVector<OpFoldResult>> exactShape = {};
   SmallVector<int64_t> constantShapeUpperBound;
   SmallVector<int64_t> constantShapeLowerBound;
 };
@@ -181,132 +179,6 @@ getShapeAndVerifyDefinedAbove(RewriterBase &rewriter,
   return result;
 }
 
-static FailureOr<DestinationOperandMaterializationResult>
-materializeDestinationOperand(RewriterBase &rewriter, Location loc,
-                              plan::InlineGroupOp op, unsigned resultIdx,
-                              DataFlowSolver &solver) {
-  OpBuilder::InsertionGuard g(rewriter);
-  rewriter.setInsertionPoint(op);
-  op->getParentOfType<ModuleOp>();
-  auto rtt = dyn_cast<RankedTensorType>(op.getResultTypes()[resultIdx]);
-
-  if (rtt.hasStaticShape()) {
-    DestinationOperandMaterializationResult result;
-    result.strategy = DestinationOperandMaterializationStrategy::ExactShape,
-    result.destinationOperand =
-        rewriter
-            .create<tensor::EmptyOp>(loc, rtt.getShape(), rtt.getElementType())
-            .getResult();
-    result.constantShapeLowerBound = llvm::to_vector(rtt.getShape());
-    result.constantShapeUpperBound = llvm::to_vector(rtt.getShape());
-    return result;
-  };
-
-  // Any time the result has dynamic shape, we should be yielding a
-  // `plan.with_shape` result.
-  auto withShapeOp =
-      op.getYieldedValueForResult(resultIdx).getDefiningOp<plan::WithShapeOp>();
-  if (!withShapeOp)
-    return emitError(op.getLoc()) << "expected cluster to yield the result of "
-                                     "a 'plan.with_shape' operation but got "
-                                  << op.getYieldedValueForResult(resultIdx);
-
-  // Check that all dimensions are constants or defined above:
-  FailureOr<SmallVector<OpFoldResult>> exactShape =
-      getShapeAndVerifyDefinedAbove(rewriter, op, withShapeOp);
-  if (failed(exactShape))
-    return op->emitOpError()
-           << "expected the shape calculation to be materialized above the "
-              "cluster region but some dynamic dimension "
-              " extent value is defined within the cluster region; this "
-              "indicates that the result shape is in the so-called "
-              "'data-dependent dynamic shapes' regime, "
-              "which is currently not supported for TensorRT cluster regions";
-
-  DestinationOperandMaterializationResult result;
-  result.destinationOperand = Value{};
-  result.exactShape = std::move(*exactShape);
-
-  FailureOr<SmallVector<int64_t>> minShape =
-      getShapeBoundsForValue(op.getYieldedValueForResult(resultIdx),
-                             presburger::BoundType::LB, solver);
-  if (succeeded(minShape)) {
-    result.constantShapeLowerBound = *minShape;
-  } else {
-    LLVM_DEBUG(
-        DBGS() << "failed to derive shape lower bound, filling with zeros\n");
-    result.constantShapeLowerBound = SmallVector<int64_t>(rtt.getRank(), 0);
-  }
-
-  // If there are not static shapes, then first we can try to query the
-  // value bounds analysis for the max shape.
-  FailureOr<SmallVector<int64_t>> maxShape =
-      getShapeBoundsForValue(op.getYieldedValueForResult(resultIdx),
-                             presburger::BoundType::UB, solver);
-
-  if (failed(maxShape))
-    // TODO: try materializing non-static upper bound
-    return failure();
-
-  int64_t shapeProduct = mlir::computeProduct(*maxShape);
-
-  LLVM_DEBUG(DBGS() << llvm::formatv(
-                 "computed max shape = {0:$[, ]}; product={1}\n",
-                 llvm::make_range(maxShape->begin(), maxShape->end()),
-                 shapeProduct));
-
-  // Any shaped type that is < 0 is invalid as it indicates an
-  // overflow from signed integer arithmetic.
-  if (llvm::any_of(*maxShape, [](int64_t dim) { return dim < 0; }) ||
-      shapeProduct < 0)
-    return op->emitOpError() << llvm::formatv(
-               "failed to calculate upper bound for cluster result #{0}; got "
-               "max shape {1:$[, ]} which has linear size {2}",
-               resultIdx, llvm::make_range(maxShape->begin(), maxShape->end()),
-               shapeProduct);
-
-  // We allocate a linearized buffer since the output of dynamic regions
-  // will create a dynamic tensor with a packed layout.
-  {
-    Value maxEmptyLinearValue = rewriter.create<tensor::EmptyOp>(
-        loc, ArrayRef<int64_t>{shapeProduct}, rtt.getElementType());
-
-    // materialize the linearized size.
-    SmallVector<AffineExpr> shape;
-    shape.reserve(maxShape->size());
-    for (unsigned symbolIdx = 0; symbolIdx < maxShape->size(); symbolIdx++)
-      shape.push_back(rewriter.getAffineSymbolExpr(symbolIdx));
-
-    OpFoldResult linearizedActualSize = affine::makeComposedFoldedAffineApply(
-        rewriter, loc, mlir::computeProduct(rewriter.getContext(), shape),
-        *result.exactShape);
-
-    auto sliceOp = rewriter.create<tensor::ExtractSliceOp>(
-        loc, maxEmptyLinearValue,
-        /*offsets=*/
-        ArrayRef<OpFoldResult>{rewriter.getIndexAttr(0)},
-        /*sizes=*/ArrayRef<OpFoldResult>{linearizedActualSize},
-        /*strides=*/
-        ArrayRef<OpFoldResult>{rewriter.getIndexAttr(1)});
-    if (sliceOp.getType() == op->getResultTypes()[resultIdx]) {
-      result.destinationOperand = sliceOp.getResult();
-    } else {
-      SmallVector<Value> shapeElements =
-          getValueOrCreateConstantIndexOp(rewriter, loc, *result.exactShape);
-      Value shapeValue =
-          rewriter.create<tensor::FromElementsOp>(loc, shapeElements);
-      result.destinationOperand = rewriter.create<tensor::ReshapeOp>(
-          loc, op.getResultTypes()[resultIdx], sliceOp.getResult(), shapeValue);
-    }
-  }
-
-  result.constantShapeUpperBound = *maxShape;
-  // Cast back to a dynamic shape so that it matches the originally required
-  // type.
-  result.strategy = DestinationOperandMaterializationStrategy::UpperBound;
-  return result;
-}
-
 /// Determines whether a cluster being outlined should clone a constant or
 /// pass constant by value.
 static bool shouldCloneProducer(Operation *producer, Region &cluster) {
@@ -338,39 +210,12 @@ static void remapLatticeState(DataFlowSolver &solver, Value original,
   }
 }
 
-/// Remap relevant analysis states from `originals` to `replacements`.
-static void remapAnalysisState(DataFlowSolver &solver, ValueRange originals,
-                               ValueRange replacements) {
-  for (auto [original, replacement] :
-       llvm::zip_equal(originals, replacements)) {
-    remapLatticeState<TensorKindLattice>(solver, original, replacement);
-    remapLatticeState<ShapeBoundsLattice>(solver, original, replacement);
-    remapLatticeState<IntegerValueRangeLattice>(solver, original, replacement);
-    remapLatticeState<Lattice<ConstantValue>>(solver, original, replacement);
-    remapLatticeState<TensorValueBoundsLattice>(solver, original, replacement);
-  }
-}
-
 static LogicalResult createClosedGroupOp(RewriterBase &rewriter,
                                          plan::InlineGroupOp op,
                                          DataFlowSolver &solver) {
   OpBuilder::InsertionGuard g(rewriter);
   Location loc = op.getLoc();
 
-  // Materialize the destination operands.
-  SmallVector<DestinationOperandMaterializationResult> destinationOperands;
-  destinationOperands.reserve(op.getNumResults());
-  for (OpResult res : op->getOpResults()) {
-    FailureOr<DestinationOperandMaterializationResult> destResult =
-        materializeDestinationOperand(rewriter, res.getLoc(), op,
-                                      res.getResultNumber(), solver);
-    if (failed(destResult))
-      return emitError(res.getLoc())
-             << "failed to materialize destination operand of type "
-             << res.getType();
-    destinationOperands.push_back(*destResult);
-  }
-
   // Make the region isolated from above. This captures the input operands.
   SmallVector<Value> inputs = makeRegionIsolatedFromAbove(
       rewriter, op.getRegion(), [&](Operation *producer) {
@@ -378,12 +223,11 @@ static LogicalResult createClosedGroupOp(RewriterBase &rewriter,
       });
 
   rewriter.setInsertionPoint(op);
+
+  // Create a new closed group op and move blocks into it.
   auto closedGroupOp = rewriter.create<InlineClosedGroupOp>(
-      op.getLoc(), /*target=*/op.getTarget(),
-      /*inputs=*/inputs,
-      /*outs=*/
-      llvm::map_to_vector(destinationOperands,
-                          [](const auto &x) { return x.destinationOperand; }));
+      op.getLoc(), /*result type*/ op->getResultTypes(), /*target=*/op.getTarget(),
+      /*inputs=*/inputs);
 
   rewriter.inlineBlockBefore(
       &op.getRegion().front(), &closedGroupOp.getRegion().front(),
@@ -391,29 +235,10 @@ static LogicalResult createClosedGroupOp(RewriterBase &rewriter,
       closedGroupOp.getRegion().getArguments().take_front(
           op.getRegion().getNumArguments()));
 
-  SmallVector<Value> replacements;
-  replacements.reserve(destinationOperands.size());
-  for (auto [newResult, destOperand, originalType] :
-       llvm::zip(closedGroupOp->getResults(), destinationOperands,
-                 op->getResultTypes())) {
-    if (destOperand.strategy ==
-        DestinationOperandMaterializationStrategy::ExactShape) {
-      replacements.push_back(newResult);
-      continue;
-    }
-
-    assert(destOperand.exactShape &&
-           "expected materialized shape values to be provided for "
-           "this materialization strategy");
-
-    replacements.push_back(newResult);
-  }
+  DBGS() << "Number of inline op results: " << op->getNumResults() << "\n"; 
+  DBGS() << "Number of closed group op results: " << closedGroupOp->getNumResults() << "\n"; 
 
-  // Since we are about to replace values that may be inputs to other regions
-  // ops, we need to update the solver to populate the replacement TensorKind
-  // information.
-  remapAnalysisState(solver, op->getResults(), replacements);
-  rewriter.replaceOp(op, replacements);
+  rewriter.replaceOp(op, closedGroupOp->getResults());
 
   SmallVector<TensorKindInfo> inputTensorKinds;
   inputTensorKinds.reserve(inputs.size());
@@ -431,20 +256,6 @@ static LogicalResult createClosedGroupOp(RewriterBase &rewriter,
     inputTensorKinds.push_back(tensorKindLattice->getValue());
   }
 
-  // Create the closed region result profile attrs.
-  SmallVector<BoundsAttr> resultAttrs;
-  for (const DestinationOperandMaterializationResult &dest :
-       destinationOperands) {
-    auto boundsAttr = BoundsAttr::getChecked(
-        mlir::detail::getDefaultDiagnosticEmitFn(loc), rewriter.getContext(),
-        BoundsKind::Shape, ArrayRef(dest.constantShapeLowerBound),
-        ArrayRef(dest.constantShapeUpperBound));
-    if (!boundsAttr)
-      return failure();
-    resultAttrs.push_back(boundsAttr);
-  }
-  closedGroupOp.setResAttrsAttr(resultAttrs);
-
   // Create the shape profile attributes for the inputs.
   SmallVector<BoundsAttr> inputAttrs;
   inputAttrs.reserve(inputTensorKinds.size());
diff --git a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/MaterializeShapeCalculations.cpp b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/MaterializeShapeCalculations.cpp
index e1af50d5b..d3fa0be13 100644
--- a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/MaterializeShapeCalculations.cpp
+++ b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/MaterializeShapeCalculations.cpp
@@ -72,7 +72,7 @@ static WithShapeOp createWithShapeOp(RewriterBase &rewriter, Location loc,
         loc, v, rewriter.create<arith::ConstantIndexOp>(loc, i));
     dims.push_back(dimOp);
   }
-  return rewriter.create<plan::WithShapeOp>(loc, v, dims);
+  return rewriter.create<plan::WithShapeOp>(loc, v.getType(), v, dims);
 }
 
 /// If `v` is dynamically shaped, replace uses with `plan.with_shape` of `v`.
@@ -112,7 +112,7 @@ createWithValuesOp(RewriterBase &rewriter, Location loc, Value v,
     newUsers.insert(extractOp);
     elements.push_back(extractOp);
   }
-  return rewriter.create<plan::WithValuesOp>(loc, v, elements);
+  return rewriter.create<plan::WithValuesOp>(loc, v.getType(), v, elements);
 }
 
 /// For each tensor-typed value, create a `plan.with_shape` operation and
diff --git a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/OutlineClusters.cpp b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/OutlineClusters.cpp
index 6a0911c17..a3df44df2 100644
--- a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/OutlineClusters.cpp
+++ b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/OutlineClusters.cpp
@@ -173,7 +173,7 @@ static LogicalResult outlineTensorRTRegion(RewriterBase &rewriter,
 
   rewriter.setInsertionPoint(op);
   auto callOp = rewriter.create<tensorrt::CallOp>(
-      op.getLoc(), op.getResultTypes(), op.getInputs(), op.getOuts(),
+      op.getLoc(), op.getResultTypes(), op.getInputs(),
       SymbolRefAttr::get(trtModuleOp.getNameAttr(),
                          {FlatSymbolRefAttr::get(*func)}));
 
@@ -203,31 +203,6 @@ static LogicalResult outlineTensorRTRegion(RewriterBase &rewriter,
     func->setArgAttr(i, mlir::getHostTensorArgAttrName(),
                      rewriter.getUnitAttr());
   }
-  // Populate the function result attributes.
-  for (unsigned i = 0; i < (*func).getNumResults(); i++) {
-    BoundsAttr srcAttr = cast<BoundsAttr>(op.getResAttrs()[i]);
-    if (srcAttr.isNone())
-      continue;
-    FailureOr<tensorrt::ShapeProfileAttr> boundsAttr =
-        getTensorRTShapeProfile(srcAttr, op.getResults()[i]);
-    if (failed(boundsAttr))
-      return op->emitOpError("failed to create TensorRT shape profile "
-                             "attribute from Plan BoundsAttr for result #")
-             << i << " (" << srcAttr << ")";
-    if (srcAttr.isShapeBound()) {
-      func->setResultAttr(
-          i, tensorrt::TensorRTDialect::getShapeProfileArgAttrName(),
-          *boundsAttr);
-      continue;
-    }
-    assert(srcAttr.isValueBound() && "expected value bound or shape bound");
-    func->setResultAttr(
-        i, tensorrt::TensorRTDialect::getShapeTensorValueBoundsArgAttrName(),
-        *boundsAttr);
-    func->setResultAttr(i, mlir::getHostTensorArgAttrName(),
-                        rewriter.getUnitAttr());
-  }
-
   // Populate the function entry block.
   rewriter.eraseBlock(&func->getFunctionBody().front());
 
@@ -254,14 +229,6 @@ static LogicalResult outlineTensorRTRegion(RewriterBase &rewriter,
   rewriter.setInsertionPoint(regionYieldOp);
   rewriter.replaceOpWithNewOp<func::ReturnOp>(regionYieldOp,
                                               regionYieldOp->getOperands());
-
-  // Erase the DPS arugments, which now should be unused.
-  if (llvm::any_of(func->getArguments().take_back(op.getOuts().size()),
-                   [](BlockArgument arg) { return !arg.use_empty(); }))
-    return failure();
-  func->getFunctionBody().front().eraseArguments(op.getInputs().size(),
-                                                 op.getOuts().size());
-
   // replace the original region results.
   rewriter.replaceOp(op, callOp);
   return success();
diff --git a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/RefineTypes.cpp b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/RefineTypes.cpp
index c3afeff89..1126b90ec 100644
--- a/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/RefineTypes.cpp
+++ b/mlir-tensorrt/compiler/lib/Dialect/Plan/Transforms/RefineTypes.cpp
@@ -255,7 +255,7 @@ struct WithShapeAbsorbCastPattern : public OpRewritePattern<WithShapeOp> {
     }
 
     auto newWithShapeOp = rewriter.create<WithShapeOp>(
-        op.getLoc(), castOp.getOperand(), op.getShape());
+        op.getLoc(), castOp->getResultTypes(), castOp.getOperand(), op.getShape());
     rewriter.replaceOpWithNewOp<tensor::CastOp>(op, op.getType(),
                                                 newWithShapeOp);
     return success();
diff --git a/mlir-tensorrt/compiler/lib/Dialect/TensorRTRuntime/IR/TensorRTRuntime.cpp b/mlir-tensorrt/compiler/lib/Dialect/TensorRTRuntime/IR/TensorRTRuntime.cpp
index 65c2c83a0..bde285bc0 100644
--- a/mlir-tensorrt/compiler/lib/Dialect/TensorRTRuntime/IR/TensorRTRuntime.cpp
+++ b/mlir-tensorrt/compiler/lib/Dialect/TensorRTRuntime/IR/TensorRTRuntime.cpp
@@ -37,23 +37,6 @@ using namespace mlir::trtrt;
 // EnqueueOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult EnqueueOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  EnqueueOp::Adaptor adaptor(operands, attributes, properties, regions);
-
-  // If the `outs` operands are tensor types, then we shoudl return those as
-  // results. Otherwise, for memref outs, we do not return results.
-  for (Type t : TypeRange(adaptor.getOuts())) {
-    auto tensorType = dyn_cast<TensorType>(t);
-    if (!tensorType)
-      continue;
-    inferredReturnTypes.push_back(tensorType);
-  }
-  return success();
-}
-
 LogicalResult EnqueueOp::verify() {
   if (std::optional<ArrayRef<int64_t>> hostTensorIndices =
           getHostTensorArgs()) {
@@ -103,14 +86,6 @@ void EnqueueOp::getEffects(
     effects.emplace_back(MemoryEffects::Read::get(), &operand,
                          SideEffects::DefaultResource::get());
   }
-  for (OpOperand &operand : getOutsMutable()) {
-    if (!llvm::isa<MemRefType>(operand.get().getType()))
-      continue;
-    effects.emplace_back(MemoryEffects::Read::get(), &operand,
-                         SideEffects::DefaultResource::get());
-    effects.emplace_back(MemoryEffects::Write::get(), &operand,
-                         SideEffects::DefaultResource::get());
-  }
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/mlir-tensorrt/compiler/lib/Dialect/TensorRTRuntime/Transforms/BufferizableOpInterfaceImpl.cpp b/mlir-tensorrt/compiler/lib/Dialect/TensorRTRuntime/Transforms/BufferizableOpInterfaceImpl.cpp
index 8656fd4da..352dd39e5 100644
--- a/mlir-tensorrt/compiler/lib/Dialect/TensorRTRuntime/Transforms/BufferizableOpInterfaceImpl.cpp
+++ b/mlir-tensorrt/compiler/lib/Dialect/TensorRTRuntime/Transforms/BufferizableOpInterfaceImpl.cpp
@@ -21,8 +21,8 @@
 #include "mlir-tensorrt/Dialect/Plan/IR/Plan.h"
 #include "mlir-tensorrt/Dialect/TensorRTRuntime/IR/TensorRTRuntime.h"
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
-#include "mlir/Dialect/Bufferization/IR/DstBufferizableOpInterfaceImpl.h"
 #include "llvm/ADT/STLExtras.h"
+#include "mlir/IR/DialectRegistry.h"
 
 using namespace mlir;
 using namespace mlir::trtrt;
@@ -43,54 +43,52 @@ static bool isInMemorySpace(Type memrefType, plan::MemorySpace memType) {
 
 namespace {
 struct EnqueueOpInterface
-    : public bufferization::DstBufferizableOpInterfaceExternalModel<
+    : public bufferization::BufferizableOpInterface::ExternalModel<
           EnqueueOpInterface, EnqueueOp> {
-  /// Only our dps input operands are read. Dps init are guaranteed to be just
-  /// outputs in our use-case.
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               const bufferization::AnalysisState &state) const {
-    EnqueueOp callOp = cast<EnqueueOp>(op);
-    return callOp.isDpsInput(&opOperand);
+    // All operands are read
+    return true;
   }
 
-  /// Only dps inits are written.
-  bool
-  bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                          const bufferization::AnalysisState &state) const {
-    EnqueueOp callOp = cast<EnqueueOp>(op);
-    return callOp.isDpsInit(&opOperand);
+  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
+                               const bufferization::AnalysisState &state) const {
+    // The op doesn't write to its operands
+    return false;
   }
 
-  // TensorRT will guarantee that the input will be read before the result
-  // buffer is written.
-  bool bufferizesToElementwiseAccess(Operation *op,
-                                     const bufferization::AnalysisState &state,
-                                     ArrayRef<OpOperand *> opOperands) const {
-    return true;
+  bufferization::AliasingValueList getAliasingValues(Operation *op, OpOperand &opOperand,
+                                      const bufferization::AnalysisState &state) const {
+    return {};
+  }
+
+  bool mustBufferizeInPlace(Operation *op, OpOperand &opOperand,
+                            const bufferization::AnalysisState &state) const {
+    // EnqueueOp creates new outputs, doesn't modify inputs in-place
+    return false;
   }
 
   /// Bufferize the `trtrt.enqueue` operation.
   LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
                           const BufferizationOptions &options) const {
-    EnqueueOp callOp = cast<EnqueueOp>(op);
+    EnqueueOp enqueueOp = cast<EnqueueOp>(op);
     MLIRContext *ctx = op->getContext();
     Location loc = op->getLoc();
-    rewriter.setInsertionPoint(callOp);
+    rewriter.setInsertionPoint(enqueueOp);
 
     // For the inputs, check the memory space and insert a copy if it is not in
-    // the correct space.
+    // the correct space.    SmallVector<Value> newInputBuffers;
     SmallVector<Value> newInputBuffers;
-    newInputBuffers.reserve(callOp.getNumDpsInputs());
+    newInputBuffers.reserve(enqueueOp->getNumOperands());
     for (auto [idx, opOperand] :
-         llvm::enumerate(callOp.getDpsInputOperands())) {
-
-      // The context and steam operands are considered "DPS inputs" and
-      // therefore they'll be skipped here.
-      if (callOp.isScalar(opOperand)) {
-        newInputBuffers.push_back(opOperand->get());
+         llvm::enumerate(enqueueOp->getOperands())) {
+      if (!isa<TensorType, MemRefType>(opOperand.getType())) {
+        // This is a scalar or non-tensor/memref type
+        newInputBuffers.push_back(opOperand);
         continue;
       }
-      FailureOr<Value> buffer = getBuffer(rewriter, opOperand->get(), options);
+
+      FailureOr<Value> buffer = getBuffer(rewriter, opOperand, options);
       if (failed(buffer))
         return failure();
 
@@ -99,7 +97,7 @@ struct EnqueueOpInterface
       // Check if this input is a host tensor. Insert a copy if required. Note
       // that we subtract two from the index to account for context/stream
       // arguments.
-      if (callOp.isOperandOnHost(idx) &&
+      if (enqueueOp.isOperandOnHost(idx) &&
           !isInMemorySpace(memRefType, plan::MemorySpace::host_pinned)) {
         FailureOr<Value> pinnedAlloc = options.createAlloc(
             rewriter, op->getLoc(),
@@ -117,10 +115,10 @@ struct EnqueueOpInterface
       }
 
       // If we are in host space, then copy to the device.
-      if (!callOp.isOperandOnHost(idx) &&
-          !isInMemorySpace(memRefType, plan::MemorySpace::device)) {
+      if (!enqueueOp.isOperandOnHost(idx) &&
+         !isInMemorySpace(memRefType, plan::MemorySpace::device)) {
         FailureOr<Value> devAlloc = options.createAlloc(
-            rewriter, op->getLoc(),
+            rewriter, loc,
             MemRefType::get(
                 memRefType.getShape(), memRefType.getElementType(),
                 memRefType.getLayout(),
@@ -133,28 +131,30 @@ struct EnqueueOpInterface
         newInputBuffers.push_back(*devAlloc);
         continue;
       }
-
-      // We are in device space, nothing to do.
-      newInputBuffers.push_back(*buffer);
+        // We are in device space, nothing to do.
+        newInputBuffers.push_back(*buffer);
     }
 
-    SmallVector<Value> newOutputBuffers;
-    newOutputBuffers.reserve(callOp.getNumDpsInits());
-    for (OpResult opResult : op->getOpResults()) {
-      OpOperand *opOperand =
-          callOp.getDpsInitOperand(opResult.getResultNumber());
-      FailureOr<Value> resultBuffer =
-          getBuffer(rewriter, opOperand->get(), options);
-      if (failed(resultBuffer))
-        return failure();
-      newOutputBuffers.push_back(*resultBuffer);
+    // Handle the output
+    SmallVector<Type> resultTypes;
+    for (Type resultType : enqueueOp->getResultTypes()) {
+      if (auto tensorType = resultType.dyn_cast<TensorType>()) {
+        // Convert TensorType to MemrefType
+        resultTypes.push_back(MemRefType::get(
+            tensorType.getShape(), tensorType.getElementType(),
+            MemRefLayoutAttrInterface(),
+            plan::MemorySpaceAttr::get(ctx, plan::MemorySpace::device)));
+      } else {
+        resultTypes.push_back(resultType);
+      }
     }
 
-    rewriter.create<EnqueueOp>(
-        op->getLoc(), newInputBuffers[0], newInputBuffers[1],
-        ValueRange(newInputBuffers).drop_front(2), newOutputBuffers,
-        callOp.getHostTensorArgsAttr());
-    replaceOpWithBufferizedValues(rewriter, op, newOutputBuffers);
+    // Create the bufferized EnqueueOp
+    auto newOp = rewriter.create<EnqueueOp>(loc, resultTypes, newInputBuffers[0], newInputBuffers[1], ValueRange(newInputBuffers).drop_front(2), enqueueOp.getHostTensorArgsAttr());
+
+    // Replace the old op with the new one
+    replaceOpWithBufferizedValues(rewriter, op, newOp->getResults());
+
     return success();
   }
 };
diff --git a/mlir-tensorrt/executor/include/mlir-executor/Executor/IR/ExecutorOps.td b/mlir-tensorrt/executor/include/mlir-executor/Executor/IR/ExecutorOps.td
index fdde1f5b7..9bf0cfcdb 100644
--- a/mlir-tensorrt/executor/include/mlir-executor/Executor/IR/ExecutorOps.td
+++ b/mlir-tensorrt/executor/include/mlir-executor/Executor/IR/ExecutorOps.td
@@ -438,7 +438,7 @@ def Executor_FuncOp : Executor_Op<"func", [IsolatedFromAbove,
 def Executor_CallOp : Executor_Op<"call", [
     CallOpInterface,
     DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
-  let summary = "call to an Executor IR function";
+  let summary = "call to an Executor IR function that returns outputs without mutating inputs";
 
   let description = [{
     The `executor.call` operation represents a procedure call to an externally
@@ -446,6 +446,8 @@ def Executor_CallOp : Executor_Op<"call", [
     by passing `args` as well as immediate operands (attribute values) given
     by `immediate_args`. The `immediate_args` attribute is optional.
 
+    This operation does not mutate its input arguments and produces new outputs.
+
     If `immediate_args` is not specified, then the values in `args` are
     passed to `callee` in the order that they are listed.
 
@@ -455,7 +457,7 @@ def Executor_CallOp : Executor_Op<"call", [
     Currently, `immediate_args` values are restricted to be integers
     attributes.
 
-    The function definition is currently not checked the verify that passing
+    The function definition is currently not checked to verify that passing
     immediate args makes sense. It is only verified against the types of
     `args` and `results`.
   }];
@@ -493,6 +495,8 @@ def Executor_CallOp : Executor_Op<"call", [
       (*this)->setAttr("callee", callee.get<SymbolRefAttr>());
     }
 
+    // Note: This method is provided for compile-time IR transformations
+    // and does not imply that the operation mutates its inputs during execution.
     MutableOperandRange getArgOperandsMutable() {
       return getArgsMutable();
     }
diff --git a/mlir-tensorrt/executor/lib/Runtime/Backend/Lua/Modules/TensorRT/TensorRTModule.cpp b/mlir-tensorrt/executor/lib/Runtime/Backend/Lua/Modules/TensorRT/TensorRTModule.cpp
index 1b96eac44..4121e0d09 100644
--- a/mlir-tensorrt/executor/lib/Runtime/Backend/Lua/Modules/TensorRT/TensorRTModule.cpp
+++ b/mlir-tensorrt/executor/lib/Runtime/Backend/Lua/Modules/TensorRT/TensorRTModule.cpp
@@ -419,6 +419,14 @@ void mlirtrt::runtime::registerExecutorTensorRTModuleLuaRuntimeMethods(
         sol::state_view luaState(state);
         assert(context != nullptr);
         assert(stream != nullptr && "expected valid stream");
+
+        // Allocate output buffers lazily i.e.
+        // a) Register a nullptr for output memory address and register a IOutputAllocator.
+        // b) TRT call back will reallocate memory, register name, and populate output dims.
+        // c) Ensure that reallocated memory is owned by the RuntimeClient.
+        // Return a tuple of string, pointer and dims.
+        std::vector<std::tuple<std::string, uintptr_t, nvinfer1::Dims>> outputs;
+
         Status result = enqueueV3Wrapper(*allocTracker, *resourceTracker,
                                          *context, stream, va);
         SET_LUA_ERROR_IF_ERROR(result, state);
diff --git a/mlir-tensorrt/log b/mlir-tensorrt/log
new file mode 100644
index 000000000..87a6410bb
--- /dev/null
+++ b/mlir-tensorrt/log
@@ -0,0 +1,1544 @@
+Load new dialect in Context pdl_interp
+Load new dialect in Context vector
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::vector::MaskableOpInterface)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::vector::MaskingOpInterface)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::VectorTransferOpInterface)
+Loaded TensorRT version 10.2.0.21 but compiled for TensorRT 10.2.0.19. This can result in crashes or unintended behavior.
+[translate-to-tensorrt] TranslateToTensorRTEnginePass is generating a new TensorRT builder
+[translate-to-tensorrt] timing cache path was not specified, creating a fresh timing cache
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::CallGraph)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::DialectFoldInterface)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::ConstantLike<Empty>)
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasRecursiveMemoryEffects<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::detail::PreservedAnalyses::AllAnalysesType)
+* Inliner: Initial calls in SCC are: {
+}
+* Inliner: Initial calls in SCC are: {
+}
+
+//===-------------------------------------------===//
+Legalizing operation : 'builtin.module'(0x56bdd0480b10) {
+  * Fold {
+  } -> FAILURE : unable to fold
+} -> FAILURE : no matched legalization pattern
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'func.func'(0x56bdd048d1d0) {
+  * Fold {
+  } -> FAILURE : unable to fold
+} -> FAILURE : no matched legalization pattern
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+  * Fold {
+  } -> FAILURE : unable to fold
+} -> FAILURE : no matched legalization pattern
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+  * Fold {
+  } -> FAILURE : unable to fold
+} -> FAILURE : no matched legalization pattern
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern (anonymous namespace)::ConvertTypesInFuncReturnOp : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::ConvertTypesInFuncReturnOp"
+"(anonymous namespace)::ConvertTypesInFuncReturnOp" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+
+  * Pattern mlir::(anonymous namespace)::FunctionOpInterfaceSignatureConversion : 'func.func -> ()' {
+Trying to match "mlir::(anonymous namespace)::FunctionOpInterfaceSignatureConversion"
+"mlir::(anonymous namespace)::FunctionOpInterfaceSignatureConversion" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern"
+    ** Match Failure : expected integer result tensor type
+"mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern"
+    ** Match Failure : doesn't need refinement
+"mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern"
+    ** Match Failure : doesn't need update
+"mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern (anonymous namespace)::AbsorbCastsIntoFuncReturnPattern : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern"
+"(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::VariadicResults<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNOperands<1>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::vector::YieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::RegionBranchOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::MemRefType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneOperand<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::ViewLikeOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::VectorType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::VectorUnrollOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNOperands<2>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AttrSizedOperandSegments<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::VectorTransferOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::vector::MaskableOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::DestinationStyleOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::InferTypeOpAdaptor<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNOperands<4>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::NResults<2>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::Type>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::arith::ArithFastMathInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNOperands<3>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::vector::MaskingOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::NOperands<3>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::Scalarizable<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::Vectorizable<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::Tensorizable<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::IndexType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNSuccessors<1>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneSuccessor<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::NSuccessors<2>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::pdl::PDLType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::pdl::RangeType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::pdl::ValueType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::pdl::OperationType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::pdl::TypeType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::pdl::AttributeType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::pdl_interp::ForEachOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SameTypeOperands<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::vhlo::VersionedOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::NRegions<2>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::vhlo::VersionedOpConstraintInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::NOperands<4>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::NOperands<5>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::VariadicRegions<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::NResults<3>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::TensorKindOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::trtrt::TensorRTRuntimeOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::trtrt::RuntimeType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::trtrt::ExecutionContextType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::TransformOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::TransformEachOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::ReportTrackingListenerFailuresOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::FunctionalStyleTransformOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::transform::YieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::MatchOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::PossibleTopLevelTransformOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::transform::TransformHandleTypeInterface>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::NavigationTransformOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::transform::TransformParamTypeInterface>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::ParamProducerTransformOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SameOperandsAndResultType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::SingleOpMatcherOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::AtMostOneOpMatcherOpTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::CallOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::SymbolUserOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::transform::TransformValueHandleTypeInterface>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNResults<1>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::CastOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::ConversionPatternDescriptorOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNRegions<1>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::transform::PatternDescriptorOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::tensorrt::IfOp, mlir::tensorrt::ForOp, mlir::tensorrt::WhileOp, mlir::tensorrt::OpaquePluginOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::tensorrt::TensorRTOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::tensorrt::TensorRTInferCompleteTensorTypeTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::tensorrt::TensorRTInferPartialTensorTypeTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SameOperandsAndResultElementType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::InferTensorType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::ReifyRankedShapedTypeOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::tensorrt::YieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::LoopLikeOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SameOperandsElementType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::tensorrt::WhileOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::CompatibleOperandsAndResultType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::stablehlo::ReturnOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::RecursivelySpeculatableImplTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::TensorType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::SpeculatableIfStaticDimInOutputIsStaticInInputImplTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::CompatibleOperandsAndResultElementType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::RecursivelySpeculatableIfAllInputsStaticImplTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::BroadcastingElementwise<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::RecursivelySpeculatableIfStaticDimInOutputIsStaticInInputImplTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::PairwiseSameOperandAndResultType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::SpeculatableIfAllInputsStaticAndShapeConstantImplTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::CompatibleOperandsElementType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::hlo::OpTrait::PairwiseSameOperandAndResultElementType<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::shape::ReduceOp, mlir::shape::FunctionLibraryOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::shape::ValueShapeType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::ShapedType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::IntegerType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::IsCommutative<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::shape::FuncOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::shape::YieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::shape::SizeType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::shape::ShapeType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::shape::WitnessType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::shape::AssumingOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::shape::AssumingYieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::scf::ExecuteRegionOp, mlir::scf::ForOp, mlir::scf::IfOp, mlir::scf::IndexSwitchOp, mlir::scf::WhileOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::scf::ReduceOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::scf::ParallelOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::scf::ReduceOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParallelRegion<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::scf::YieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::scf::ForallOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::ParallelCombiningOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::scf::InParallelOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::scf::WhileOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::plan::InlineGroupOp, mlir::plan::InlineClosedGroupOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::plan::PlanOpTrait::PlanDialectOp<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::plan::YieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::pdl::PatternOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::pdl::RewriteOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::BranchOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::executor::RuntimeBuiltinInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::executor::ExecutorOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::executor::StrLiteralType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::PromotableMemOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::executor::LowerToFuncCallTrait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::executor::PointerType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::executor::TableType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::PromotableAllocationOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::cuda::CUDAOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::cuda::StreamType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNOperands<9>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::cuda::FunctionType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::FloatType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::cuda::EventType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNOperands<5>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::cuda::BlasGemmAlgorithmType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::cuda::BlasHandleType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::chlo::OpTrait::Broadcasting<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::bufferization::BufferizableOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::BaseMemRefType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::SubsetOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::SubsetInsertionOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::CopyOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::bufferization::AllocationOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::linalg::YieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::linalg::LinalgOp::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::linalg::ContractionOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::linalg::ConvolutionOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::linalg::FillOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::linalg::AggregatedOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::TilingInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::tensor::GenerateOp, mlir::tensor::PadOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OffsetSizeAndStrideOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::tensor::YieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::ShapedDimOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::ComplexType>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::DestructurableAccessorOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::AtLeastNResults<2>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::memref::AllocaScopeOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::memref::AllocaScopeReturnOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::DestructurableAllocationOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::memref::AtomicYieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SameOperandsShape<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::HasParent<mlir::memref::GenericAtomicRMWOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::affine::AffineWriteOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::affine::AffineMapAccessInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::affine::AffineReadOpInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::SingleBlockImplicitTerminator<mlir::affine::AffineYieldOp>::Impl<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::InferIntRangeInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::arith::ArithRoundingModeInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::arith::ArithIntegerOverflowFlagsInterface::Trait<Empty>)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::IsIdempotent<Empty>)
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'func.func -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+    ** Match Failure : not stablehlo
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::AddOpCanon : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::AddOpCanon"
+"mlir::stablehlo::(anonymous namespace)::AddOpCanon" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp"
+    ** Match Failure : expected to be unary
+"mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern (anonymous namespace)::FixInvalidReturnWorkaround : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::FixInvalidReturnWorkaround"
+"(anonymous namespace)::FixInvalidReturnWorkaround" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+    ** Match Failure : not stablehlo
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern"
+    ** Match Failure : expected integer result tensor type
+"mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern"
+    ** Match Failure : doesn't need refinement
+"mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern"
+    ** Match Failure : doesn't need update
+"mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern (anonymous namespace)::AbsorbCastsIntoFuncReturnPattern : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern"
+"(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'func.func -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+    ** Match Failure : not stablehlo
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::AddOpCanon : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::AddOpCanon"
+"mlir::stablehlo::(anonymous namespace)::AddOpCanon" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp"
+    ** Match Failure : expected to be unary
+"mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern (anonymous namespace)::FixInvalidReturnWorkaround : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::FixInvalidReturnWorkaround"
+"(anonymous namespace)::FixInvalidReturnWorkaround" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+    ** Match Failure : not stablehlo
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern"
+    ** Match Failure : expected integer result tensor type
+"mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern"
+    ** Match Failure : doesn't need refinement
+"mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern"
+    ** Match Failure : doesn't need update
+"mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern (anonymous namespace)::AbsorbCastsIntoFuncReturnPattern : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern"
+"(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'func.func -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+    ** Match Failure : not stablehlo
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::AddOpCanon : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::AddOpCanon"
+"mlir::stablehlo::(anonymous namespace)::AddOpCanon" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp"
+    ** Match Failure : expected to be unary
+"mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern (anonymous namespace)::FixInvalidReturnWorkaround : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::FixInvalidReturnWorkaround"
+"(anonymous namespace)::FixInvalidReturnWorkaround" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+    ** Match Failure : not stablehlo
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern"
+    ** Match Failure : expected integer result tensor type
+"mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern"
+    ** Match Failure : doesn't need refinement
+"mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern"
+    ** Match Failure : doesn't need update
+"mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern (anonymous namespace)::AbsorbCastsIntoFuncReturnPattern : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern"
+"(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::DominanceInfo)
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'func.func -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+    ** Match Failure : not stablehlo
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::AddOpCanon : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::AddOpCanon"
+"mlir::stablehlo::(anonymous namespace)::AddOpCanon" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp"
+    ** Match Failure : expected to be unary
+"mlir::stablehlo::(anonymous namespace)::ReorderElementwiseAndShapeOp" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern (anonymous namespace)::FixInvalidReturnWorkaround : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::FixInvalidReturnWorkaround"
+"(anonymous namespace)::FixInvalidReturnWorkaround" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon"
+    ** Match Failure : not stablehlo
+"mlir::stablehlo::(anonymous namespace)::ZeroExtentTensorCanon" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern"
+    ** Match Failure : expected integer result tensor type
+"mlir::stablehlo::(anonymous namespace)::EvalAddOpPattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern"
+    ** Match Failure : doesn't need refinement
+"mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern"
+    ** Match Failure : doesn't need update
+"mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern (anonymous namespace)::AbsorbCastsIntoFuncReturnPattern : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern"
+"(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'builtin.module'(0x56bdd0480b10) {
+} -> SUCCESS : operation marked legal by the target
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'func.func'(0x56bdd048d1d0) {
+} -> SUCCESS : operation marked legal by the target
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> SUCCESS : operation marked legal by the target
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> SUCCESS : operation marked legal by the target
+//===-------------------------------------------===//
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::dataflow::CFGEdge)
+Priming analysis: mlir::dataflow::DeadCodeAnalysis
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::dataflow::Executable)
+Propagating update to mlir::dataflow::Executable of ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+  func.return %0 : tensor<2x3x4xf32>
+
+Value: live
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::dataflow::PredecessorState)
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Priming analysis: mlir::dataflow::SparseConstantPropagation
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::dataflow::Lattice<mlir::dataflow::ConstantValue>)
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: <UNKNOWN>
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+  func.return %0 : tensor<2x3x4xf32>
+
+SCP: Visiting operation: %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Value: <UNKNOWN>
+Priming analysis: mlir::TensorKindAnalysis
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::TensorKindLattice)
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Creating dependency between mlir::TensorKindLattice of %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+and mlir::TensorKindLattice on %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: device
+[plan-materialize-shape-calculations] after adding shape reification operations:
+func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
+  %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+  return %0 : tensor<2x3x4xf32>
+}
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern : 'stablehlo.add -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern"
+    ** Match Failure : doesn't need refinement
+"mlir::stablehlo::(anonymous namespace)::RefineInferTypeOpInterfacePattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+
+  * Pattern (anonymous namespace)::AbsorbCastsIntoFuncReturnPattern : 'func.return -> ()' {
+Trying to match "(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern"
+"(anonymous namespace)::AbsorbCastsIntoFuncReturnPattern" result 0
+  } -> failure : pattern failed to match
+
+  * Pattern mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern : 'func.return -> ()' {
+Trying to match "mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern"
+    ** Match Failure : doesn't need update
+"mlir::stablehlo::(anonymous namespace)::UpdateFunctionTypePattern" result 0
+  } -> failure : pattern failed to match
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+Priming analysis: mlir::dataflow::DeadCodeAnalysis
+Propagating update to mlir::dataflow::Executable of ^bb0:
+  func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
+    %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+    return %0 : tensor<2x3x4xf32>
+  }
+
+Value: live
+Propagating update to mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+Value: predecessors:
+
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+Propagating update to mlir::dataflow::Executable of ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+  func.return %0 : tensor<2x3x4xf32>
+
+Value: live
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Priming analysis: mlir::dataflow::SparseConstantPropagation
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+  func.return %0 : tensor<2x3x4xf32>
+
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: <UNKNOWN>
+SCP: Visiting operation: %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Value: <UNKNOWN>
+Priming analysis: mlir::TensorKindAnalysis
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Value: device
+Creating dependency between mlir::TensorKindLattice of %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+and mlir::TensorKindLattice on %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: device
+Priming analysis: mlir::dataflow::DeadCodeAnalysis
+Propagating update to mlir::dataflow::Executable of ^bb0:
+  func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
+    %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+    return %0 : tensor<2x3x4xf32>
+  }
+
+Value: live
+Propagating update to mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+Value: predecessors:
+
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+Propagating update to mlir::dataflow::Executable of ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+  func.return %0 : tensor<2x3x4xf32>
+
+Value: live
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Priming analysis: mlir::dataflow::SparseConstantPropagation
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+  func.return %0 : tensor<2x3x4xf32>
+
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: <UNKNOWN>
+SCP: Visiting operation: %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Value: <UNKNOWN>
+Priming analysis: mlir::TensorKindAnalysis
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Value: device
+Creating dependency between mlir::TensorKindLattice of %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+and mlir::TensorKindLattice on %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: device
+Priming analysis: mlir::dataflow::DeadCodeAnalysis
+Priming analysis: mlir::dataflow::SparseConstantPropagation
+SCP: Visiting operation: %0 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+Priming analysis: mlir::TensorKindAnalysis
+// [clustering]: [Target: #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>] Initializing all clusterable operations to single-op clusters.
+
+//===-------------------------------------------===//
+Legalizing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+  * Fold {
+  } -> FAILURE : unable to fold
+
+  * Pattern : 'stablehlo.add -> ()' {
+Trying to match "(anonymous namespace)::HloBinaryOpConverter<mlir::stablehlo::AddOp, mlir::tensorrt::ElementWiseOperation::kSUM>"
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::tensorrt::detail::ElementWiseOpGenericAdaptorBase::Properties)
+    ** Insert  : 'tensorrt.element_wise'(0x56be60796350)
+    ** Replace : 'stablehlo.add'(0x56bdd048c790)
+"(anonymous namespace)::HloBinaryOpConverter<mlir::stablehlo::AddOp, mlir::tensorrt::ElementWiseOperation::kSUM>" result 1
+
+    //===-------------------------------------------===//
+    Legalizing operation : 'tensorrt.element_wise'(0x56be60796350) {
+      %0 = "tensorrt.element_wise"(%arg0, %arg0) <{elementwiseOperation = #tensorrt.element_wise_operation<kSUM>}> : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+    } -> SUCCESS : operation marked legal by the target
+    //===-------------------------------------------===//
+  } -> SUCCESS : pattern applied successfully
+// *** IR Dump After Pattern Application ***
+func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
+  %0 = tensorrt.element_wise <kSUM>(%arg0, %arg0 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+  %1 = stablehlo.add %arg0, %arg0 : tensor<2x3x4xf32>
+  return %1 : tensor<2x3x4xf32>
+}
+
+
+} -> SUCCESS
+//===-------------------------------------------===//
+// [clustering]: [Target: #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>] After ID assignment:
+module {
+  func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
+    %0 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+    return %0 : tensor<2x3x4xf32>
+  }
+}
+// [clustering]: [Target: #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>] After running initial BFS clustering:
+module {
+  func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
+    %0 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+    return %0 : tensor<2x3x4xf32>
+  }
+}
+// [clustering]: [Target: #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>] Attempting to merge all pairs of clusters
+// [clustering]: [Target: #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>] After merging independent clusters:
+module {
+  func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
+    %0 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+    return %0 : tensor<2x3x4xf32>
+  }
+}
+[clustering-patterns]num clusters before filtering: 1
+[clustering-patterns]num clusters after filtering: 1
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::plan::detail::InlineGroupOpGenericAdaptorBase::Properties)
+Priming analysis: mlir::dataflow::DeadCodeAnalysis
+Propagating update to mlir::dataflow::Executable of ^bb0:
+  %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+  plan.yield %1 : tensor<2x3x4xf32>
+
+Value: live
+Propagating update to mlir::dataflow::PredecessorState of ^bb0:
+  %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+  plan.yield %1 : tensor<2x3x4xf32>
+
+Value: (all) predecessors:
+  %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+  %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+  yield %1 : tensor<2x3x4xf32>
+}
+
+Propagating update to mlir::dataflow::PredecessorState of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Value: (all) predecessors:
+  plan.yield %1 : tensor<2x3x4xf32>
+
+Priming analysis: mlir::dataflow::SparseConstantPropagation
+Creating dependency between mlir::dataflow::PredecessorState of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+and mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Value: <UNKNOWN>
+SCP: Visiting operation: %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Priming analysis: mlir::TensorKindAnalysis
+Propagating update to mlir::TensorKindLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Value: device
+Creating dependency between mlir::TensorKindLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::TensorKindLattice on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::TensorKindLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::TensorKindLattice on plan.yield %1 : tensor<2x3x4xf32>
+// [clustering]: [Target: #plan.host_cluster<benefit = 9>] Initializing all clusterable operations to single-op clusters.
+[builtin-cluster-kinds] should run on host? %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+  %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+  yield %1 : tensor<2x3x4xf32>
+}
+[builtin-cluster-kinds]   types not all host compatible
+[builtin-cluster-kinds] should run on host? func.return %0 : tensor<2x3x4xf32>
+[builtin-cluster-kinds]   types not all host compatible
+[clustering-patterns]num clusters before filtering: 0
+[clustering-patterns]num clusters after filtering: 0
+Priming analysis: mlir::dataflow::DeadCodeAnalysis
+Priming analysis: mlir::dataflow::SparseConstantPropagation
+SCP: Visiting operation: %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Priming analysis: mlir::TensorKindAnalysis
+Priming analysis: mlir::dataflow::DeadCodeAnalysis
+Propagating update to mlir::dataflow::Executable of ^bb0:
+  func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {
+    %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+      %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+      yield %1 : tensor<2x3x4xf32>
+    }
+    return %0 : tensor<2x3x4xf32>
+  }
+
+Value: live
+Propagating update to mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+Value: predecessors:
+
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+Propagating update to mlir::dataflow::Executable of ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+    %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+    yield %1 : tensor<2x3x4xf32>
+  }
+  func.return %0 : tensor<2x3x4xf32>
+
+Value: live
+Propagating update to mlir::dataflow::Executable of ^bb0:
+  %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+  plan.yield %1 : tensor<2x3x4xf32>
+
+Value: live
+Propagating update to mlir::dataflow::PredecessorState of ^bb0:
+  %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+  plan.yield %1 : tensor<2x3x4xf32>
+
+Value: (all) predecessors:
+  %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+  %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+  yield %1 : tensor<2x3x4xf32>
+}
+
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Priming analysis: mlir::dataflow::SparseConstantPropagation
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+    %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+    yield %1 : tensor<2x3x4xf32>
+  }
+  func.return %0 : tensor<2x3x4xf32>
+
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: <UNKNOWN>
+Creating dependency between mlir::dataflow::PredecessorState of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+SCP: Visiting operation: %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Value: <UNKNOWN>
+Priming analysis: mlir::plan::ShapeIntegerRangeAnalysis
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::dataflow::IntegerValueRangeLattice)
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+    %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+    yield %1 : tensor<2x3x4xf32>
+  }
+  func.return %0 : tensor<2x3x4xf32>
+
+Creating dependency between mlir::dataflow::PredecessorState of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Priming analysis: mlir::plan::ShapeBoundsForwardAnalysis
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::plan::ShapeBoundsLattice)
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+    %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+    yield %1 : tensor<2x3x4xf32>
+  }
+  func.return %0 : tensor<2x3x4xf32>
+
+Propagating update to mlir::plan::ShapeBoundsLattice of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: <[2, 2], [3, 3], [4, 4]>
+Creating dependency between mlir::dataflow::PredecessorState of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+ [plan-bounds-analysis][ShapeBoundsForwardAnalysis] visiting %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Propagating update to mlir::plan::ShapeBoundsLattice of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Value: <[2, 2], [3, 3], [4, 4]>
+Priming analysis: mlir::plan::ShapeBoundsBackwardsAnalysis
+ [plan-bounds-analysis][ShapeBoundsBackwardsAnalysis] visiting func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+ [plan-bounds-analysis][ShapeBoundsBackwardsAnalysis] setting to exit state: %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Propagating update to mlir::plan::ShapeBoundsLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Value: <[2, 2], [3, 3], [4, 4]>
+Creating dependency between mlir::plan::ShapeBoundsLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::plan::ShapeBoundsLattice on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::plan::ShapeBoundsLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::plan::ShapeBoundsLattice on plan.yield %1 : tensor<2x3x4xf32>
+Creating dependency between mlir::plan::ShapeBoundsLattice of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+and mlir::plan::ShapeBoundsLattice on %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+ [plan-bounds-analysis][ShapeBoundsBackwardsAnalysis] visiting %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Priming analysis: mlir::TensorKindAnalysis
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Value: device
+Creating dependency between mlir::TensorKindLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::TensorKindLattice on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::TensorKindLattice of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::TensorKindLattice on plan.yield %1 : tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Value: device
+Creating dependency between mlir::TensorKindLattice of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+and mlir::TensorKindLattice on %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: device
+Priming analysis: mlir::plan::TensorValueBoundsAnalysis
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::plan::TensorValueBoundsLattice)
+Creating dependency between mlir::dataflow::PredecessorState of func.func @main(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {
+    %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+    yield %1 : tensor<2x3x4xf32>
+  }
+  func.return %0 : tensor<2x3x4xf32>
+
+Creating dependency between mlir::dataflow::PredecessorState of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+and mlir::dataflow::PredecessorState on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+ [plan-bounds-analysis][TensorValueBoundsAnalysis] visiting %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+Invoking 'mlir::dataflow::DeadCodeAnalysis' on: plan.yield %1 : tensor<2x3x4xf32>
+Propagating update to mlir::dataflow::PredecessorState of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Value: (all) predecessors:
+  plan.yield %1 : tensor<2x3x4xf32>
+
+Invoking 'mlir::dataflow::SparseConstantPropagation' on: %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+and mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Value: <UNKNOWN>
+Invoking 'mlir::plan::ShapeIntegerRangeAnalysis' on: %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::dataflow::IntegerValueRangeLattice of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+and mlir::dataflow::IntegerValueRangeLattice on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Invoking 'mlir::plan::ShapeBoundsForwardAnalysis' on: %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::plan::ShapeBoundsLattice of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+and mlir::plan::ShapeBoundsLattice on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Invoking 'mlir::plan::TensorValueBoundsAnalysis' on: %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+Creating dependency between mlir::plan::TensorValueBoundsLattice of %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+and mlir::plan::TensorValueBoundsLattice on %0 = plan.inline_group target(#plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>) attributes {__cluster_target__ = #plan.tensorrt_cluster<disallow_shape_tensor_calculations = false, benefit = 10>} -> tensor<2x3x4xf32> {...}
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::plan::detail::InlineClosedGroupOpGenericAdaptorBase::Properties)
+[plan-create-closed-regions] Number of inline op results1
+[plan-create-closed-regions] Number of closed group op results1
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::tensorrt::detail::CallOpGenericAdaptorBase::Properties)
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56be61ce14a0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'tensorrt.module'(0x56be61186550) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56be61ce0370) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) {cluster.root = 95373243238288 : i64} : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%1) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'tensorrt.call'(0x56be61185bd0) {
+  %1 = "tensorrt.call"(%arg1) <{callee = @trt_engines::@tensorrt_cluster}> : (tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%1) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'tensorrt.call'(0x56be61185bd0) {
+  %1 = "tensorrt.call"(%arg1) <{callee = @trt_engines::@tensorrt_cluster}> : (tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56be61ce14a0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56be61ce0370) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) {cluster.root = 95373243238288 : i64} : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'tensorrt.module'(0x56be61186550) {
+} -> SUCCESS : operation marked legal by the target
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'func.func'(0x56be61ce0370) {
+} -> SUCCESS : operation marked legal by the target
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'stablehlo.add'(0x56bdd048c790) {
+  %0 = "stablehlo.add"(%arg0, %arg0) {cluster.root = 95373243238288 : i64} : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+  * Fold {
+  } -> FAILURE : unable to fold
+
+  * Pattern : 'stablehlo.add -> ()' {
+Trying to match "(anonymous namespace)::HloBinaryOpConverter<mlir::stablehlo::AddOp, mlir::tensorrt::ElementWiseOperation::kSUM>"
+    ** Insert  : 'tensorrt.element_wise'(0x56be60796350)
+    ** Replace : 'stablehlo.add'(0x56bdd048c790)
+"(anonymous namespace)::HloBinaryOpConverter<mlir::stablehlo::AddOp, mlir::tensorrt::ElementWiseOperation::kSUM>" result 1
+
+    //===-------------------------------------------===//
+    Legalizing operation : 'tensorrt.element_wise'(0x56be60796350) {
+      %0 = "tensorrt.element_wise"(%arg0, %arg0) <{elementwiseOperation = #tensorrt.element_wise_operation<kSUM>}> : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+    } -> SUCCESS : operation marked legal by the target
+    //===-------------------------------------------===//
+  } -> SUCCESS : pattern applied successfully
+// *** IR Dump After Pattern Application ***
+func.func @tensorrt_cluster(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> attributes {cluster.tensorrt} {
+  %0 = tensorrt.element_wise <kSUM>(%arg0, %arg0 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+  %1 = stablehlo.add %arg0, %arg0 {cluster.root = 95373243238288 : i64} : tensor<2x3x4xf32>
+  return %1 : tensor<2x3x4xf32>
+}
+
+
+} -> SUCCESS
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Legalizing operation : 'func.return'(0x56be61ce14a0) {
+  "func.return"(%1) : (tensor<2x3x4xf32>) -> ()
+
+} -> SUCCESS : operation marked legal by the target
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56be61ce14a0) {
+  "func.return"(%0) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'tensorrt.module'(0x56be61186550) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56be61ce0370) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'tensorrt.element_wise'(0x56be60796350) {
+  %0 = "tensorrt.element_wise"(%arg0, %arg0) <{elementwiseOperation = #tensorrt.element_wise_operation<kSUM>}> : (tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.return'(0x56bdd048ccd0) {
+  "func.return"(%1) : (tensor<2x3x4xf32>) -> ()
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'func.func'(0x56bdd048d1d0) {
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+
+//===-------------------------------------------===//
+Processing operation : 'tensorrt.call'(0x56be61185bd0) {
+  %1 = "tensorrt.call"(%arg1) <{callee = @trt_engines::@tensorrt_cluster}> : (tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+
+} -> failure : pattern failed to match
+//===-------------------------------------------===//
+Priming analysis: mlir::dataflow::DeadCodeAnalysis
+Propagating update to mlir::dataflow::Executable of ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = tensorrt.element_wise <kSUM>(%arg0, %arg0 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+  func.return %0 : tensor<2x3x4xf32>
+
+Value: live
+Creating dependency between mlir::dataflow::PredecessorState of func.func @tensorrt_cluster(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> attributes {cluster.tensorrt} {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Priming analysis: mlir::dataflow::SparseConstantPropagation
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: <UNKNOWN>
+Creating dependency between mlir::dataflow::PredecessorState of func.func @tensorrt_cluster(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> attributes {cluster.tensorrt} {...}
+and mlir::dataflow::PredecessorState on ^bb0(%arg0: tensor<2x3x4xf32>):
+  %0 = tensorrt.element_wise <kSUM>(%arg0, %arg0 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+  func.return %0 : tensor<2x3x4xf32>
+
+SCP: Visiting operation: %0 = tensorrt.element_wise <kSUM>(%arg0, %arg0 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+Propagating update to mlir::dataflow::Lattice<mlir::dataflow::ConstantValue> of %0 = tensorrt.element_wise <kSUM>(%arg0, %arg0 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+Value: <UNKNOWN>
+Priming analysis: mlir::TensorKindAnalysis
+Creating dependency between mlir::dataflow::PredecessorState of func.func @tensorrt_cluster(%arg0: tensor<2x3x4xf32>) -> tensor<2x3x4xf32> attributes {cluster.tensorrt} {...}
+and mlir::dataflow::PredecessorState on func.return %0 : tensor<2x3x4xf32>
+Creating dependency between mlir::TensorKindLattice of %0 = tensorrt.element_wise <kSUM>(%arg0, %arg0 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+and mlir::TensorKindLattice on %0 = tensorrt.element_wise <kSUM>(%arg0, %arg0 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+Propagating update to mlir::TensorKindLattice of <block argument> of type 'tensor<2x3x4xf32>' at index: 0
+Value: device
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::trtrt::detail::CompileOpGenericAdaptorBase::Properties)
+ImplicitTypeIDRegistry::lookupOrInsert(mlir::cuda::detail::GetGlobalStreamOpGenericAdaptorBase::Properties)
+python3: /workspaces/TensorRT-Incubator/mlir-tensorrt/llvm-project/mlir/lib/IR/PatternMatch.cpp:135: virtual void mlir::RewriterBase::replaceOp(Operation *, ValueRange): Assertion `op->getNumResults() == newValues.size() && "incorrect # of replacement values"' failed.
diff --git a/mlir-tensorrt/tensorrt/include/mlir-tensorrt-dialect/TensorRT/IR/TensorRTOps.td b/mlir-tensorrt/tensorrt/include/mlir-tensorrt-dialect/TensorRT/IR/TensorRTOps.td
index 213911c96..179a70c47 100644
--- a/mlir-tensorrt/tensorrt/include/mlir-tensorrt-dialect/TensorRT/IR/TensorRTOps.td
+++ b/mlir-tensorrt/tensorrt/include/mlir-tensorrt-dialect/TensorRT/IR/TensorRTOps.td
@@ -3,7 +3,6 @@
 
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
-include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
@@ -85,14 +84,11 @@ def TensorRT_TensorRTModuleOp : TensorRT_Op<"module", [
 
 def TensorRT_CallOp : TensorRT_Op<"call", [
   DeclareOpInterfaceMethods<SymbolUserOpInterface>,
-  DestinationStyleOpInterface,
-  AttrSizedOperandSegments,
   CallOpInterface
 ]> {
   let summary = "calls a TensorRT engine defined in a `tensorrt.module`";
 
   let arguments = (ins Variadic<AnyTypeOf<[AnyShaped, AnySignlessIntegerOrIndex]>>:$inputs,
-                       Variadic<AnyShaped>:$outputs,
                        SymbolRefAttr:$callee);
   let results = (outs Variadic<AnyShaped>:$results);
 
@@ -100,14 +96,11 @@ def TensorRT_CallOp : TensorRT_Op<"call", [
     /// Return the function representing the TRT engine that is being called.
     func::FuncOp getFuncCallee(SymbolTableCollection &symbolTable);
 
-    // Declare the outputs as inits/outs to DestinationStyleOpInterface.
-    MutableOperandRange getDpsInitsMutable() { return getOutputsMutable(); }
-
     //===------------------------------------------------------------------===//
     // CallOpInterface
     //===------------------------------------------------------------------===//
     operand_range getArgOperands() {
-      return getOperation()->getOperands();
+      return getInputs();
     }
     CallInterfaceCallable getCallableForCallee() {
       return (*this)->getAttrOfType<SymbolRefAttr>("callee");
@@ -118,13 +111,12 @@ def TensorRT_CallOp : TensorRT_Op<"call", [
     }
 
     MutableOperandRange getArgOperandsMutable() {
-      return MutableOperandRange(getOperation());
+      return getInputsMutable();
     }
   }];
 
   let assemblyFormat = [{
     $callee `(` ($inputs^ `:` type($inputs))? `)`
-    `outs` `(` $outputs `:` type($outputs) `)`
     attr-dict (`->` type($results)^)?
   }];
 }
diff --git a/mlir-tensorrt/test/Target/Lua/IntegrationTests/ClusteringDynamicShape/stablehlo-func-call.mlir b/mlir-tensorrt/test/Target/Lua/IntegrationTests/ClusteringDynamicShape/stablehlo-func-call.mlir
new file mode 100644
index 000000000..06a0dcc4a
--- /dev/null
+++ b/mlir-tensorrt/test/Target/Lua/IntegrationTests/ClusteringDynamicShape/stablehlo-func-call.mlir
@@ -0,0 +1,16 @@
+// RUN: mlir-tensorrt-opt %s  \
+// RUN: -pass-pipeline="builtin.module(stablehlo-preprocessing-pipeline{disable-inliner},\
+// RUN: stablehlo-clustering-pipeline, \
+// RUN: post-clustering-pipeline, \
+// RUN: executor-lowering-pipeline)" \
+// RUN: | mlir-tensorrt-translate -mlir-to-runtime-executable -allow-unregistered-dialect |  mlir-tensorrt-runner -input-type=rtexe --use-custom-allocator
+
+func.func @add(%0: tensor<1xf32>, %1: tensor<1xf32>) -> tensor<1xf32> {
+    %2 = stablehlo.add %0, %1 : (tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>
+    return %2 : tensor<1xf32>
+}
+
+func.func @main(%arg0: tensor<1xf32>) -> tensor<1xf32>  {
+  %1 = func.call @add(%arg0, %arg0) : (tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>
+  func.return %1 : tensor<1xf32>
+}
\ No newline at end of file
diff --git a/mlir-tensorrt/test/python/IntegrationTests/test_stablehlo_add.py b/mlir-tensorrt/test/python/IntegrationTests/test_stablehlo_add.py
index 2c95a3081..4a803fdf0 100644
--- a/mlir-tensorrt/test/python/IntegrationTests/test_stablehlo_add.py
+++ b/mlir-tensorrt/test/python/IntegrationTests/test_stablehlo_add.py
@@ -25,6 +25,7 @@ def stablehlo_add():
             client,
             ["--tensorrt-builder-opt-level=3", "--tensorrt-strongly-typed=false"],
         )
+        opts.set_debug_options(True, [], "tmp")
         exe = compiler.compiler_stablehlo_to_executable(client, m.operation, opts)
 
     # The RuntimeClient can and should persist across multiple Executables, RuntimeSessions, etc.
@@ -56,20 +57,6 @@ def stablehlo_add():
 
     print(data)
 
-    # Run execution a bunch more times asynchronously so that it calculates
-    # `x * 2**num_iter`.
-    num_iter = 5
-    start_time = time.time()
-    for _ in range(0, num_iter):
-        session.execute_function("main", in_args=[arg0], out_args=[arg0], stream=stream)
-    data = np.asarray(client.copy_to_host(arg1, stream=stream))
-    stream.sync()
-    end_time = time.time()
-    elapsed = end_time - start_time
-
-    print(np.asarray(client.copy_to_host(arg0)))
-    print(f"1000 iterations avg { (elapsed/num_iter)/1000.0} msec per iteration")
-
 
 if __name__ == "__main__":
     stablehlo_add()
diff --git a/mlir-tensorrt/test/python/IntegrationTests/test_stablehlo_dynamic.py b/mlir-tensorrt/test/python/IntegrationTests/test_stablehlo_dynamic.py
index 35515e054..c4d668db0 100644
--- a/mlir-tensorrt/test/python/IntegrationTests/test_stablehlo_dynamic.py
+++ b/mlir-tensorrt/test/python/IntegrationTests/test_stablehlo_dynamic.py
@@ -101,8 +101,7 @@ def test_program(program: str, input_shape: Iterable[int], debug: bool = True):
                 "--entrypoint=main",
             ],
         )
-        if debug:
-            opts.set_debug_options(False, [], "tmp")
+        opts.set_debug_options(True, [], "tmp")
         exe = compiler.compiler_stablehlo_to_executable(client, m.operation, opts)
 
     # The RuntimeClient can and should persist across multiple Executables, RuntimeSessions, etc.
@@ -146,8 +145,8 @@ def test_program(program: str, input_shape: Iterable[int], debug: bool = True):
 if __name__ == "__main__":
     print("Test (3, ?, 2)")
     test_program(program1, (3, 4, 2))
-    print("Test (?, 2)")
-    test_program(program2, (4, 2))
+    # print("Test (?, 2)")
+    # test_program(program2, (4, 2))
 
 # CHECK-LABEL: Test (3, ?, 2)
 #       CHECK: [{{\[}}[2. 2.]