diff --git a/Cargo.toml b/Cargo.toml
index e6f53ff..f3ce055 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,10 +23,10 @@ path = "src/bin/wasm-snip.rs"
 required-features = ["exe"]
 
 [dependencies]
-failure = "0.1.5"
-walrus = { version = "0.12.0", features = ["parallel"] }
+walrus = { version = "0.23.2", features = ["parallel"] }
 regex = "1.3.1"
 rayon = "1.2.0"
+anyhow = "1.0"
 
 [dependencies.clap]
 optional = true
diff --git a/src/bin/wasm-snip.rs b/src/bin/wasm-snip.rs
index 12d38d7..03e2e41 100644
--- a/src/bin/wasm-snip.rs
+++ b/src/bin/wasm-snip.rs
@@ -1,12 +1,13 @@
-use failure::ResultExt;
 use std::fs;
 use std::io::{self, Write};
 use std::process;
 
+use anyhow::Context;
+
 fn main() {
     if let Err(e) = try_main() {
         eprintln!("error: {}", e);
-        for c in e.iter_chain().skip(1) {
+        for c in e.chain().skip(1) {
             eprintln!("  caused by {}", c);
         }
         eprintln!("{}", e.backtrace());
@@ -14,7 +15,7 @@ fn main() {
     }
 }
 
-fn try_main() -> Result<(), failure::Error> {
+fn try_main() -> Result<(), anyhow::Error> {
     let matches = parse_args();
 
     let mut opts = wasm_snip::Options::default();
@@ -43,7 +44,7 @@ fn try_main() -> Result<(), failure::Error> {
 
     let config = walrus_config_from_options(&opts);
     let path = matches.value_of("input").unwrap();
-    let buf = fs::read(&path).with_context(|_| format!("failed to read file {}", path))?;
+    let buf = fs::read(&path).with_context(|| format!("failed to read file {}", path))?;
     let mut module = config.parse(&buf)?;
 
     wasm_snip::snip(&mut module, opts).context("failed to snip functions from wasm module")?;
@@ -51,7 +52,7 @@ fn try_main() -> Result<(), failure::Error> {
     if let Some(output) = matches.value_of("output") {
         module
             .emit_wasm_file(output)
-            .with_context(|_| format!("failed to emit snipped wasm to {}", output))?;
+            .with_context(|| format!("failed to emit snipped wasm to {}", output))?;
     } else {
         let wasm = module.emit_wasm();
         let stdout = io::stdout();
diff --git a/src/lib.rs b/src/lib.rs
index c475caa..63a71d7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -105,7 +105,7 @@ dual licensed as above, without any additional terms or conditions.
 #![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 
-use failure::ResultExt;
+use anyhow::Context;
 use rayon::prelude::*;
 use std::collections::HashMap;
 use std::collections::HashSet;
@@ -152,7 +152,7 @@ pub struct Options {
 }
 
 /// Snip the functions from the input file described by the options.
-pub fn snip(module: &mut walrus::Module, options: Options) -> Result<(), failure::Error> {
+pub fn snip(module: &mut walrus::Module, options: Options) -> Result<(), anyhow::Error> {
     if !options.skip_producers_section {
         module
             .producers
@@ -173,7 +173,7 @@ pub fn snip(module: &mut walrus::Module, options: Options) -> Result<(), failure
     Ok(())
 }
 
-fn build_regex_set(mut options: Options) -> Result<regex::RegexSet, failure::Error> {
+fn build_regex_set(mut options: Options) -> Result<regex::RegexSet, anyhow::Error> {
     // Snip the Rust `fmt` code, if requested.
     if options.snip_rust_fmt_code {
         // Mangled symbols.
@@ -253,7 +253,7 @@ fn replace_calls_with_unreachable(
     }
 
     impl VisitorMut for Replacer<'_> {
-        fn visit_instr_mut(&mut self, instr: &mut walrus::ir::Instr) {
+        fn visit_instr_mut(&mut self, instr: &mut walrus::ir::Instr, _: &mut walrus::InstrLocId) {
             if self.should_snip_call(instr) {
                 *instr = walrus::ir::Unreachable {}.into();
             }
@@ -319,31 +319,48 @@ fn snip_table_elements(module: &mut walrus::Module, to_snip: &HashSet<walrus::Fu
     };
 
     for t in module.tables.iter_mut() {
-        if let walrus::TableKind::Function(ref mut ft) = t.kind {
+        if matches!(t.element_ty, walrus::RefType::Funcref) {
             let types = &mut module.types;
             let locals = &mut module.locals;
             let funcs = &mut module.funcs;
-
-            ft.elements
-                .iter_mut()
-                .flat_map(|el| el)
-                .filter(|f| to_snip.contains(f))
-                .for_each(|el| {
-                    let ty = funcs.get(*el).ty();
-                    *el = *unreachable_funcs
-                        .entry(ty)
-                        .or_insert_with(|| make_unreachable_func(ty, types, locals, funcs));
-                });
-
-            ft.relative_elements
-                .iter_mut()
-                .flat_map(|(_, elems)| elems.iter_mut().filter(|f| to_snip.contains(f)))
-                .for_each(|el| {
-                    let ty = funcs.get(*el).ty();
-                    *el = *unreachable_funcs
-                        .entry(ty)
-                        .or_insert_with(|| make_unreachable_func(ty, types, locals, funcs));
-                });
+            let elements = &mut module.elements;
+
+            for segment in &t.elem_segments {
+                let elements = elements.get_mut(*segment);
+                match &mut elements.items {
+                    walrus::ElementItems::Functions(fs) => {
+                        fs.iter_mut()
+                            .filter(|f| to_snip.contains(f))
+                            .for_each(|el| {
+                                let ty = funcs.get(*el).ty();
+                                *el = *unreachable_funcs.entry(ty).or_insert_with(|| {
+                                    make_unreachable_func(ty, types, locals, funcs)
+                                });
+                            });
+                    }
+                    walrus::ElementItems::Expressions(walrus::RefType::Funcref, const_exprs) => {
+                        const_exprs
+                            .iter_mut()
+                            .filter_map(|f| {
+                                if let walrus::ConstExpr::RefFunc(f) = f {
+                                    Some(f)
+                                } else {
+                                    None
+                                }
+                            })
+                            .filter(|f| to_snip.contains(f))
+                            .for_each(|el| {
+                                let ty = funcs.get(*el).ty();
+                                *el = *unreachable_funcs.entry(ty).or_insert_with(|| {
+                                    make_unreachable_func(ty, types, locals, funcs)
+                                });
+                            });
+                    }
+                    walrus::ElementItems::Expressions(..) => {
+                        panic!("funcref table should only have elements of type functions")
+                    }
+                }
+            }
         }
     }
 }
diff --git a/tests/no_alloc.wasm b/tests/no_alloc.wasm
index 861ccfb..61e4334 100644
Binary files a/tests/no_alloc.wasm and b/tests/no_alloc.wasm differ
diff --git a/tests/no_fmt.wasm b/tests/no_fmt.wasm
index a439fe8..7d1b0c3 100644
Binary files a/tests/no_fmt.wasm and b/tests/no_fmt.wasm differ
diff --git a/tests/no_panicking.wasm b/tests/no_panicking.wasm
index 2bffda5..6098f48 100644
Binary files a/tests/no_panicking.wasm and b/tests/no_panicking.wasm differ
diff --git a/tests/snip_me.wasm b/tests/snip_me.wasm
index 622f57e..92a4232 100644
Binary files a/tests/snip_me.wasm and b/tests/snip_me.wasm differ