diff --git a/payload_generator/merge_sequence_generator.cc b/payload_generator/merge_sequence_generator.cc
index be8a50f..037021f 100644
--- a/payload_generator/merge_sequence_generator.cc
+++ b/payload_generator/merge_sequence_generator.cc
@@ -196,20 +196,20 @@
       new MergeSequenceGenerator(sequence, partition_name));
 }
 
-bool MergeSequenceGenerator::FindDependency(
-    std::map<CowMergeOperation, std::set<CowMergeOperation>>* result) const {
-  CHECK(result);
+std::map<CowMergeOperation, std::set<CowMergeOperation>>
+MergeSequenceGenerator::FindDependency(
+    const std::vector<CowMergeOperation>& operations) {
   LOG(INFO) << "Finding dependencies";
 
   // Since the OTA operation may reuse some source blocks, use the binary
   // search on sorted dst extents to find overlaps.
   std::map<CowMergeOperation, std::set<CowMergeOperation>> merge_after;
-  for (const auto& op : operations_) {
+  for (const auto& op : operations) {
     // lower bound (inclusive): dst extent's end block >= src extent's start
     // block.
     const auto lower_it = std::lower_bound(
-        operations_.begin(),
-        operations_.end(),
+        operations.begin(),
+        operations.end(),
         op,
         [](const CowMergeOperation& it, const CowMergeOperation& op) {
           auto dst_end_block =
@@ -219,7 +219,7 @@
     // upper bound: dst extent's start block > src extent's end block
     const auto upper_it = std::upper_bound(
         lower_it,
-        operations_.end(),
+        operations.end(),
         op,
         [](const CowMergeOperation& op, const CowMergeOperation& it) {
           auto src_end_block =
@@ -243,18 +243,12 @@
     }
   }
 
-  *result = std::move(merge_after);
-  return true;
+  return merge_after;
 }
 
 bool MergeSequenceGenerator::Generate(
     std::vector<CowMergeOperation>* sequence) const {
   sequence->clear();
-  std::map<CowMergeOperation, std::set<CowMergeOperation>> merge_after;
-  if (!FindDependency(&merge_after)) {
-    LOG(ERROR) << "Failed to find dependencies";
-    return false;
-  }
 
   LOG(INFO) << "Generating sequence";
 
@@ -262,7 +256,7 @@
   // operations to discard to break cycles; thus yielding a deterministic
   // sequence.
   std::map<CowMergeOperation, int> incoming_edges;
-  for (const auto& it : merge_after) {
+  for (const auto& it : merge_after_) {
     for (const auto& blocked : it.second) {
       // Value is default initialized to 0.
       incoming_edges[blocked] += 1;
@@ -301,7 +295,7 @@
       // Now that this particular operation is merged, other operations
       // blocked by this one may be free. Decrement the count of blocking
       // operations, and set up the free operations for the next iteration.
-      for (const auto& blocked : merge_after[op]) {
+      for (const auto& blocked : merge_after_.at(op)) {
         auto it = incoming_edges.find(blocked);
         if (it == incoming_edges.end()) {
           continue;
diff --git a/payload_generator/merge_sequence_generator.h b/payload_generator/merge_sequence_generator.h
index 1ee6861..083eedf 100644
--- a/payload_generator/merge_sequence_generator.h
+++ b/payload_generator/merge_sequence_generator.h
@@ -61,6 +61,7 @@
   explicit MergeSequenceGenerator(std::vector<CowMergeOperation> transfers,
                                   std::string_view partition_name)
       : operations_(std::move(Sort(transfers))),
+        merge_after_(FindDependency(operations_)),
         partition_name_(partition_name) {}
   // Checks that no read after write happens in the given sequence.
   static bool ValidateSequence(const std::vector<CowMergeOperation>& sequence);
@@ -69,15 +70,24 @@
   // |sequence|. Returns false on failure.
   bool Generate(std::vector<CowMergeOperation>* sequence) const;
 
+  const std::vector<CowMergeOperation>& GetOperations() const {
+    return operations_;
+  }
+  const std::map<CowMergeOperation, std::set<CowMergeOperation>>&
+  GetDependencyMap() const {
+    return merge_after_;
+  }
+
  private:
   friend class MergeSequenceGeneratorTest;
 
   // For a given merge operation, finds all the operations that should merge
-  // after myself. Put the result in |merge_after|.
-  bool FindDependency(std::map<CowMergeOperation, std::set<CowMergeOperation>>*
-                          merge_after) const;
+  // after myself. Put the result in |merge_after|. |operations| must be sorted
+  static std::map<CowMergeOperation, std::set<CowMergeOperation>>
+  FindDependency(const std::vector<CowMergeOperation>& operations);
   // The list of CowMergeOperations to sort.
   const std::vector<CowMergeOperation> operations_;
+  const std::map<CowMergeOperation, std::set<CowMergeOperation>> merge_after_;
   const std::string_view partition_name_;
 };
 
diff --git a/payload_generator/merge_sequence_generator_unittest.cc b/payload_generator/merge_sequence_generator_unittest.cc
index e1e11c0..b2c86a2 100644
--- a/payload_generator/merge_sequence_generator_unittest.cc
+++ b/payload_generator/merge_sequence_generator_unittest.cc
@@ -46,8 +46,7 @@
       std::vector<CowMergeOperation> transfers,
       std::map<CowMergeOperation, std::set<CowMergeOperation>>* result) {
     std::sort(transfers.begin(), transfers.end());
-    MergeSequenceGenerator generator(std::move(transfers), "");
-    ASSERT_TRUE(generator.FindDependency(result));
+    *result = MergeSequenceGenerator::FindDependency(transfers);
   }
 
   void GenerateSequence(std::vector<CowMergeOperation> transfers) {
