diff --git a/fuzz/fuzz_targets/ast_diff_dense_dfa.rs b/fuzz/fuzz_targets/ast_diff_dense_dfa.rs
index 2a073386a..cf83b503e 100644
--- a/fuzz/fuzz_targets/ast_diff_dense_dfa.rs
+++ b/fuzz/fuzz_targets/ast_diff_dense_dfa.rs
@@ -1,5 +1,6 @@
 #![no_main]
 
+use regex_automata::Input;
 use {
     libfuzzer_sys::{fuzz_target, Corpus},
     regex_automata::{
@@ -42,16 +43,18 @@ fn do_fuzz(data: FuzzData) -> Corpus {
         return Corpus::Reject;
     };
 
-    assert_eq!(
-        re.is_match(&data.haystack),
-        baseline.is_match(&mut cache, &data.haystack)
-    );
-    let found1 = re.find(&data.haystack);
-    let found2 = baseline.find(&mut cache, &data.haystack);
-    if let Some(found1) = found1 {
-        let found2 = found2.expect("Found in target, but not in baseline!");
-        assert_eq!(found1.start(), found2.start());
-        assert_eq!(found1.end(), found2.end());
+    if let Ok(maybe_match) = re.try_search(&Input::new(&pattern)) {
+        assert_eq!(
+            maybe_match.is_some(),
+            baseline.is_match(&mut cache, &data.haystack)
+        );
+        let found2 = baseline.find(&mut cache, &data.haystack);
+        if let Some(found1) = maybe_match {
+            let found2 =
+                found2.expect("Found in target, but not in baseline!");
+            assert_eq!(found1.start(), found2.start());
+            assert_eq!(found1.end(), found2.end());
+        }
     }
 
     // no captures
diff --git a/fuzz/fuzz_targets/ast_diff_hybrid.rs b/fuzz/fuzz_targets/ast_diff_hybrid.rs
index 700c50f9c..0e2016d93 100644
--- a/fuzz/fuzz_targets/ast_diff_hybrid.rs
+++ b/fuzz/fuzz_targets/ast_diff_hybrid.rs
@@ -1,5 +1,6 @@
 #![no_main]
 
+use regex_automata::Input;
 use {
     libfuzzer_sys::{fuzz_target, Corpus},
     regex_automata::{
@@ -43,16 +44,20 @@ fn do_fuzz(data: FuzzData) -> Corpus {
     };
     let mut hybrid_cache = re.create_cache();
 
-    assert_eq!(
-        re.is_match(&mut hybrid_cache, &data.haystack),
-        baseline.is_match(&mut cache, &data.haystack)
-    );
-    let found1 = re.find(&mut hybrid_cache, &data.haystack);
-    let found2 = baseline.find(&mut cache, &data.haystack);
-    if let Some(found1) = found1 {
-        let found2 = found2.expect("Found in target, but not in baseline!");
-        assert_eq!(found1.start(), found2.start());
-        assert_eq!(found1.end(), found2.end());
+    if let Ok(maybe_match) =
+        re.try_search(&mut hybrid_cache, &Input::new(&pattern))
+    {
+        assert_eq!(
+            maybe_match.is_some(),
+            baseline.is_match(&mut cache, &data.haystack)
+        );
+        let found2 = baseline.find(&mut cache, &data.haystack);
+        if let Some(found1) = maybe_match {
+            let found2 =
+                found2.expect("Found in target, but not in baseline!");
+            assert_eq!(found1.start(), found2.start());
+            assert_eq!(found1.end(), found2.end());
+        }
     }
 
     // no captures
diff --git a/fuzz/fuzz_targets/ast_diff_nfas.rs b/fuzz/fuzz_targets/ast_diff_nfas.rs
index 6e2670b86..294c68ba9 100644
--- a/fuzz/fuzz_targets/ast_diff_nfas.rs
+++ b/fuzz/fuzz_targets/ast_diff_nfas.rs
@@ -61,11 +61,14 @@ fn do_fuzz(data: FuzzData) -> Corpus {
         }
     }
     let mut backtracker_captures = backtracker.create_captures();
-    if let Ok(()) = backtracker.try_captures(
-        &mut backtracker_cache,
-        &data.haystack,
-        &mut backtracker_captures,
-    ) {
+    if backtracker
+        .try_captures(
+            &mut backtracker_cache,
+            &data.haystack,
+            &mut backtracker_captures,
+        )
+        .is_ok()
+    {
         let mut baseline_captures = baseline.create_captures();
 
         baseline.captures(
diff --git a/fuzz/fuzz_targets/ast_diff_sparse_dfa.rs b/fuzz/fuzz_targets/ast_diff_sparse_dfa.rs
index 4e560f685..a0fb25a12 100644
--- a/fuzz/fuzz_targets/ast_diff_sparse_dfa.rs
+++ b/fuzz/fuzz_targets/ast_diff_sparse_dfa.rs
@@ -1,5 +1,6 @@
 #![no_main]
 
+use regex_automata::Input;
 use {
     libfuzzer_sys::{fuzz_target, Corpus},
     regex_automata::{
@@ -46,16 +47,18 @@ fn do_fuzz(data: FuzzData) -> Corpus {
     };
     let re = RegexBuilder::new().build_from_dfas(fwd, rev);
 
-    assert_eq!(
-        re.is_match(&data.haystack),
-        baseline.is_match(&mut cache, &data.haystack)
-    );
-    let found1 = re.find(&data.haystack);
-    let found2 = baseline.find(&mut cache, &data.haystack);
-    if let Some(found1) = found1 {
-        let found2 = found2.expect("Found in target, but not in baseline!");
-        assert_eq!(found1.start(), found2.start());
-        assert_eq!(found1.end(), found2.end());
+    if let Ok(maybe_match) = re.try_search(&Input::new(&pattern)) {
+        assert_eq!(
+            maybe_match.is_some(),
+            baseline.is_match(&mut cache, &data.haystack)
+        );
+        let found2 = baseline.find(&mut cache, &data.haystack);
+        if let Some(found1) = maybe_match {
+            let found2 =
+                found2.expect("Found in target, but not in baseline!");
+            assert_eq!(found1.start(), found2.start());
+            assert_eq!(found1.end(), found2.end());
+        }
     }
 
     // no captures