diff --git a/src/lib.rs b/src/lib.rs
index 535ff00..9392d9c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -116,12 +116,17 @@ pub mod patch {
 }
 
 /// Normalize an error string to ignore known formatting differences between
-/// CKB VM versions. For example, one version may produce `MemWriteOnExecutablePage`
-/// while another produces `MemWriteOnExecutablePage(18)`, or `MemOutOfBound`
-/// while another produces `MemOutOfBound(4194364, Memory)`.
+/// CKB VM versions. For example, one version may produce `MemOutOfBound`
+/// while another produces `MemOutOfBound(4194364, Memory)`, or
+/// `ElfSegmentWritableAndExecutable` vs `ElfSegmentWritableAndExecutable(192065266778112)`.
 pub fn normalize_error(err: String) -> String {
     let mut result = err;
-    let patterns = ["MemWriteOnExecutablePage", "MemOutOfBound"];
+    let patterns = [
+        "MemWriteOnExecutablePage",
+        "MemOutOfBound",
+        "ElfSegmentWritableAndExecutable",
+        "ElfSegmentAddrOrSizeError",
+    ];
     for pattern in patterns {
         loop {
             // Find "Pattern(...)" and replace with just "Pattern"
diff --git a/src/main.rs b/src/main.rs
index 4ae489c..63d086f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,22 +4,27 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         "fuzz/corpus/fuzz_tx_consistency_only_valid_data1",
         "fuzz/corpus/crash"
     ];
+    let mut total_inconsistencies = 0;
     for dir in dirs {
         println!("{}", dir);
         let mut failed_corpus_v0 = 0;
         let mut success_corpus_v0 = 0;
+        let mut inconsistencies_v0 = 0;
 
         let mut failed_corpus_v1 = 0;
         let mut success_corpus_v1 = 0;
+        let mut inconsistencies_v1 = 0;
 
         for directory in std::fs::read_dir(dir)? {
             let path = directory?.path();
-            // println!("{}", path.display());
             let data = std::fs::read(path.clone())?;
 
             let r_patch = schedfuzz::patch::run(&data, 0).map_err(|e| schedfuzz::normalize_error(format!("{:?}", e)));
             let r_sched = schedfuzz::sched::run(&data, 0).map_err(|e| schedfuzz::normalize_error(format!("{:?}", e)));
-            assert_eq!(r_patch, r_sched, "file path : {}", path.display());
+            if r_patch != r_sched {
+                inconsistencies_v0 += 1;
+                eprintln!("inconsistency (version 0) file: {}\n  left:  {:?}\n  right: {:?}", path.display(), r_patch, r_sched);
+            }
             match r_patch {
                 Ok(_) => {
                     success_corpus_v0 = success_corpus_v0 + 1;
@@ -31,7 +36,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             let r_patch = schedfuzz::patch::run(&data, 2).map_err(|e| schedfuzz::normalize_error(format!("{:?}", e)));
             let r_sched = schedfuzz::sched::run(&data, 2).map_err(|e| schedfuzz::normalize_error(format!("{:?}", e)));
-            assert_eq!(r_patch, r_sched, "file path : {}", path.display());
+            if r_patch != r_sched {
+                inconsistencies_v1 += 1;
+                eprintln!("inconsistency (version 2) file: {}\n  left:  {:?}\n  right: {:?}", path.display(), r_patch, r_sched);
+            }
             match r_patch {
                 Ok(_) => {
                     success_corpus_v1 = success_corpus_v1 + 1;
@@ -41,9 +49,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 }
             }
         }
-        println!("version data  succ:{},failed:{}", success_corpus_v0, failed_corpus_v0);
-        println!("version data1  succ:{},failed:{}", success_corpus_v1, failed_corpus_v1);
+        println!("version data   succ:{}, failed:{}, inconsistencies:{}", success_corpus_v0, failed_corpus_v0, inconsistencies_v0);
+        println!("version data1  succ:{}, failed:{}, inconsistencies:{}", success_corpus_v1, failed_corpus_v1, inconsistencies_v1);
+        total_inconsistencies += inconsistencies_v0 + inconsistencies_v1;
     };
 
+    println!("\ntotal inconsistencies: {}", total_inconsistencies);
     Ok(())
 }