diff --git a/lfs.c b/lfs.c
index 84c64406..ada025c2 100644
--- a/lfs.c
+++ b/lfs.c
@@ -1160,8 +1160,10 @@ enum lfsr_tag {
     // some in-device only tag modifiers
     LFSR_TAG_RM             = 0x8000,
     LFSR_TAG_GROW           = 0x4000,
-    LFSR_TAG_SUP            = 0x2000,
-    LFSR_TAG_SUB            = 0x1000,
+    LFSR_TAG_MASK0          = 0x0000,
+    LFSR_TAG_MASK2          = 0x1000,
+    LFSR_TAG_MASK8          = 0x2000,
+    LFSR_TAG_MASK12         = 0x3000,
 };
 
 // some other tag encodings with their own subfields
@@ -1201,6 +1203,14 @@ static inline lfsr_tag_t lfsr_tag_subkey(lfsr_tag_t tag) {
     return tag & 0x00ff;
 }
 
+static inline lfsr_tag_t lfsr_tag_nonredund(lfsr_tag_t tag) {
+    return tag & 0xfffc;
+}
+
+static inline lfsr_tag_t lfsr_tag_redund(lfsr_tag_t tag) {
+    return tag & 0x0003;
+}
+
 static inline bool lfsr_tag_isalt(lfsr_tag_t tag) {
     return tag & LFSR_TAG_ALT;
 }
@@ -1229,12 +1239,28 @@ static inline bool lfsr_tag_isgrow(lfsr_tag_t tag) {
     return tag & LFSR_TAG_GROW;
 }
 
-static inline bool lfsr_tag_issup(lfsr_tag_t tag) {
-    return tag & LFSR_TAG_SUP;
+static inline bool lfsr_tag_ismask0(lfsr_tag_t tag) {
+    return ((tag >> 12) & 0x3) == 0;
 }
 
-static inline bool lfsr_tag_issub(lfsr_tag_t tag) {
-    return tag & LFSR_TAG_SUB;
+static inline bool lfsr_tag_ismask2(lfsr_tag_t tag) {
+    return ((tag >> 12) & 0x3) == 1;
+}
+
+static inline bool lfsr_tag_ismask8(lfsr_tag_t tag) {
+    return ((tag >> 12) & 0x3) == 2;
+}
+
+static inline bool lfsr_tag_ismask12(lfsr_tag_t tag) {
+    return ((tag >> 12) & 0x3) == 3;
+}
+
+static const uint16_t lfsr_tag_masktable[4] = {
+    0x0fff, 0x0ffc, 0x0f00, 0x0000
+};
+
+static inline lfsr_tag_t lfsr_tag_mask(lfsr_tag_t tag) {
+    return lfsr_tag_masktable[(tag >> 12) & 0x3];
 }
 
 // alt operations
@@ -3325,63 +3351,19 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
 // lookup assumes a known rid
 static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
         lfsr_srid_t rid, lfsr_tag_t tag,
-        lfsr_data_t *data_) {
-    lfsr_srid_t rid_;
-    lfsr_tag_t tag_;
-    int err = lfsr_rbyd_lookupnext(lfs, rbyd, rid, tag,
-            &rid_, &tag_, NULL, data_);
+        lfsr_tag_t *tag_, lfsr_data_t *data_) {
+    lfsr_srid_t rid__;
+    lfsr_tag_t tag__;
+    int err = lfsr_rbyd_lookupnext(lfs, rbyd, rid, lfsr_tag_key(tag),
+            &rid__, &tag__, NULL, data_);
     if (err) {
         return err;
     }
 
     // lookup finds the next-smallest tag, all we need to do is fail if it
     // picks up the wrong tag
-    if (rid_ != rid || tag_ != tag) {
-        return LFS_ERR_NOENT;
-    }
-
-    return 0;
-}
-
-static int lfsr_rbyd_sublookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
-        lfsr_srid_t rid, lfsr_tag_t tag,
-        lfsr_tag_t *tag_, lfsr_data_t *data_) {
-    // looking up a wide tag with subtype is probably a mistake
-    LFS_ASSERT(lfsr_tag_subtype(tag) == 0);
-
-    lfsr_srid_t rid_;
-    lfsr_tag_t tag__;
-    int err = lfsr_rbyd_lookupnext(lfs, rbyd, rid, tag,
-            &rid_, &tag__, NULL, data_);
-    if (err) {
-        return err;
-    }
-
-    // the difference between lookup and sublookup is we accept any
-    // subtype of the requested tag
-    if (rid_ != rid || lfsr_tag_suptype(tag__) != tag) {
-        return LFS_ERR_NOENT;
-    }
-
-    if (tag_) {
-        *tag_ = tag__;
-    }
-    return 0;
-}
-
-static int lfsr_rbyd_suplookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
-        lfsr_srid_t rid,
-        lfsr_tag_t *tag_, lfsr_data_t *data_) {
-    lfsr_srid_t rid_;
-    lfsr_tag_t tag__;
-    int err = lfsr_rbyd_lookupnext(lfs, rbyd, rid, 0,
-            &rid_, &tag__, NULL, data_);
-    if (err) {
-        return err;
-    }
-
-    // the difference between lookup and suplookup is we accept any tag
-    if (rid_ != rid) {
+    if (rid__ != rid
+            || (tag__ & lfsr_tag_mask(tag)) != (tag & lfsr_tag_mask(tag))) {
         return LFS_ERR_NOENT;
     }
 
@@ -3848,12 +3830,15 @@ static int lfsr_rbyd_appendrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
 
         // note both normal and rm wide-tags have the same bounds, really it's
         // the normal non-wide-tags that are an outlier here
-        if (lfsr_tag_issup(rattr.tag)) {
+        if (lfsr_tag_ismask12(rattr.tag)) {
             a_tag = 0x000;
-            b_tag = 0xf00;
-        } else if (lfsr_tag_issub(rattr.tag)) {
-            a_tag = lfsr_tag_supkey(rattr.tag);
-            b_tag = lfsr_tag_supkey(rattr.tag) + 0x100;
+            b_tag = 0xfff;
+        } else if (lfsr_tag_ismask8(rattr.tag)) {
+            a_tag = (rattr.tag & 0xf00);
+            b_tag = (rattr.tag & 0xf00) + 0x100;
+        } else if (lfsr_tag_ismask2(rattr.tag)) {
+            a_tag = (rattr.tag & 0xffc);
+            b_tag = (rattr.tag & 0xffc) + 0x004;
         } else if (lfsr_tag_isrm(rattr.tag)) {
             a_tag = lfsr_tag_key(rattr.tag);
             b_tag = lfsr_tag_key(rattr.tag) + 1;
@@ -3894,7 +3879,7 @@ trunk:;
     lfsr_srid_t lower_rid = 0;
     lfsr_srid_t upper_rid = rbyd->weight;
     lfsr_tag_t lower_tag = 0x000;
-    lfsr_tag_t upper_tag = 0xf00;
+    lfsr_tag_t upper_tag = 0xfff;
 
     // no trunk yet?
     if (!branch) {
@@ -4327,7 +4312,6 @@ stem:;
     // this gets real messy because we have a lot of special behavior built in:
     // - default         => split if tags mismatch
     // - weight>0, !grow => split if tags mismatch or we're inserting a new tag
-    // - wide-bit set    => split if suptype of tags mismatch
     // - rm-bit set      => never split, but emit alt-always tags, making our
     //                      tag effectively unreachable
     //
@@ -4337,13 +4321,8 @@ stem:;
             && (upper_rid-1 < rid-lfs_smax(-rattr.weight, 0)
                 || (upper_rid-1 == rid-lfs_smax(-rattr.weight, 0)
                     && ((!lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0)
-                        || (!lfsr_tag_issup(rattr.tag)
-                            && lfsr_tag_supkey(tag_)
-                                < lfsr_tag_supkey(rattr.tag))
-                        || (!lfsr_tag_issup(rattr.tag)
-                            && !lfsr_tag_issub(rattr.tag)
-                            && lfsr_tag_key(tag_)
-                                < lfsr_tag_key(rattr.tag)))))) {
+                        || ((tag_ & lfsr_tag_mask(rattr.tag))
+                            < (rattr.tag & lfsr_tag_mask(rattr.tag))))))) {
         if (lfsr_tag_isrm(rattr.tag) || !lfsr_tag_key(rattr.tag)) {
             // if removed, make our tag unreachable
             alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag);
@@ -4360,13 +4339,8 @@ stem:;
             && (upper_rid-1 > rid
                 || (upper_rid-1 == rid
                     && ((!lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0)
-                        || (!lfsr_tag_issup(rattr.tag)
-                            && lfsr_tag_supkey(tag_)
-                                > lfsr_tag_supkey(rattr.tag))
-                        || (!lfsr_tag_issup(rattr.tag)
-                            && !lfsr_tag_issub(rattr.tag)
-                            && lfsr_tag_key(tag_)
-                                > lfsr_tag_key(rattr.tag)))))) {
+                        || ((tag_ & lfsr_tag_mask(rattr.tag))
+                            > (rattr.tag & lfsr_tag_mask(rattr.tag))))))) {
         if (lfsr_tag_isrm(rattr.tag) || !lfsr_tag_key(rattr.tag)) {
             // if removed, make our tag unreachable
             alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag);
@@ -5284,7 +5258,8 @@ static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree,
         }
 
         if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
-            err = lfsr_rbyd_sublookup(lfs, &branch, rid__, LFSR_TAG_STRUCT,
+            err = lfsr_rbyd_lookup(lfs, &branch, rid__,
+                    LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                     &tag__, &data__);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5345,7 +5320,7 @@ static int lfsr_btree_lookupnext(lfs_t *lfs, const lfsr_btree_t *btree,
 // lfsr_btree_lookupnext, or lfsr_btree_lookupleaf + lfsr_rbyd_lookup
 static int lfsr_btree_lookup(lfs_t *lfs, const lfsr_btree_t *btree,
         lfsr_bid_t bid, lfsr_tag_t tag,
-        lfsr_data_t *data_) {
+        lfsr_tag_t *tag_, lfsr_data_t *data_) {
     // lookup rbyd in btree
     lfsr_bid_t bid_;
     lfsr_rbyd_t rbyd_;
@@ -5364,7 +5339,7 @@ static int lfsr_btree_lookup(lfs_t *lfs, const lfsr_btree_t *btree,
 
     // lookup tag in rbyd
     return lfsr_rbyd_lookup(lfs, &rbyd_, rid_, tag,
-            data_);
+            tag_, data_);
 }
 
 // TODO should lfsr_btree_lookupnext/lfsr_btree_parent be deduplicated?
@@ -5392,7 +5367,8 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree,
         }
 
         if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
-            err = lfsr_rbyd_sublookup(lfs, &branch, rid__, LFSR_TAG_STRUCT,
+            err = lfsr_rbyd_lookup(lfs, &branch, rid__,
+                    LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                     &tag__, &data__);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5589,8 +5565,8 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                 }
 
                 if (sibling_tag == LFSR_TAG_NAME) {
-                    err = lfsr_rbyd_sublookup(lfs, &parent,
-                            sibling_rid, LFSR_TAG_STRUCT,
+                    err = lfsr_rbyd_lookup(lfs, &parent, sibling_rid,
+                            LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                             &sibling_tag, &sibling_data);
                     if (err) {
                         LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5637,8 +5613,8 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                 }
 
                 if (sibling_tag == LFSR_TAG_NAME) {
-                    err = lfsr_rbyd_sublookup(lfs, &parent,
-                            sibling_rid, LFSR_TAG_STRUCT,
+                    err = lfsr_rbyd_lookup(lfs, &parent, sibling_rid,
+                            LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                             &sibling_tag, &sibling_data);
                     if (err) {
                         LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -6087,7 +6063,8 @@ static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs,
         // the name may not match exactly, but indicates which branch to follow
         lfsr_tag_t tag__;
         lfsr_data_t data__;
-        int err = lfsr_rbyd_sublookup(lfs, &branch, rid__, LFSR_TAG_STRUCT,
+        int err = lfsr_rbyd_lookup(lfs, &branch, rid__,
+                LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                 &tag__, &data__);
         if (err < 0) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -6199,7 +6176,8 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree,
         }
 
         if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
-            err = lfsr_rbyd_sublookup(lfs, bt->branch, rid__, LFSR_TAG_STRUCT,
+            err = lfsr_rbyd_lookup(lfs, bt->branch, rid__,
+                    LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                     &tag__, &data__);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -6532,9 +6510,9 @@ static int lfsr_bshrub_lookupnext(lfs_t *lfs, const lfsr_bshrub_t *bshrub,
 
 static int lfsr_bshrub_lookup(lfs_t *lfs, const lfsr_bshrub_t *bshrub,
         lfsr_bid_t bid, lfsr_tag_t tag,
-        lfsr_data_t *data_) {
+        lfsr_tag_t *tag_, lfsr_data_t *data_) {
     return lfsr_btree_lookup(lfs, &bshrub->shrub, bid, tag,
-            data_);
+            tag_, data_);
 }
 
 static int lfsr_bshrub_traverse(lfs_t *lfs, const lfsr_bshrub_t *bshrub,
@@ -7185,7 +7163,7 @@ static int lfsr_rbyd_appendgdelta(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
         // make sure to xor any existing delta
         lfsr_data_t data;
         int err = lfsr_rbyd_lookup(lfs, rbyd, -1, LFSR_TAG_GRMDELTA,
-                &data);
+                NULL, &data);
         if (err && err != LFS_ERR_NOENT) {
             return err;
         }
@@ -7225,7 +7203,7 @@ static int lfsr_fs_consumegdelta(lfs_t *lfs, const lfsr_mdir_t *mdir) {
     // consume any grm deltas
     lfsr_data_t data;
     int err = lfsr_rbyd_lookup(lfs, &mdir->rbyd, -1, LFSR_TAG_GRMDELTA,
-            &data);
+            NULL, &data);
     if (err && err != LFS_ERR_NOENT) {
         return err;
     }
@@ -7420,58 +7398,20 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir,
 
 static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
         lfsr_tag_t tag,
-        lfsr_data_t *data_) {
-    lfsr_tag_t tag_;
-    int err = lfsr_mdir_lookupnext(lfs, mdir, tag,
-            &tag_, data_);
+        lfsr_tag_t *tag_, lfsr_data_t *data_) {
+    lfsr_tag_t tag__;
+    int err = lfsr_mdir_lookupnext(lfs, mdir, lfsr_tag_key(tag),
+            &tag__, data_);
     if (err) {
         return err;
     }
 
     // lookup finds the next-smallest tag, all we need to do is fail if it
     // picks up the wrong tag
-    if (tag_ != tag) {
+    if ((tag__ & lfsr_tag_mask(tag)) != (tag & lfsr_tag_mask(tag))) {
         return LFS_ERR_NOENT;
     }
 
-    return 0;
-}
-
-static int lfsr_mdir_sublookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
-        lfsr_tag_t tag,
-        lfsr_tag_t *tag_, lfsr_data_t *data_) {
-    // looking up a wide tag with subtype is probably a mistake
-    LFS_ASSERT(lfsr_tag_subtype(tag) == 0);
-
-    lfsr_tag_t tag__;
-    int err = lfsr_mdir_lookupnext(lfs, mdir, tag,
-            &tag__, data_);
-    if (err) {
-        return err;
-    }
-
-    // the difference between lookup and sublookup is we accept any
-    // subtype of the requested tag
-    if (lfsr_tag_suptype(tag__) != tag) {
-        return LFS_ERR_NOENT;
-    }
-
-    if (tag_) {
-        *tag_ = tag__;
-    }
-    return 0;
-}
-
-static int lfsr_mdir_suplookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
-        lfsr_tag_t *tag_, lfsr_data_t *data_) {
-    lfsr_tag_t tag__;
-    int err = lfsr_mdir_lookupnext(lfs, mdir, 0,
-            &tag__, data_);
-    if (err) {
-        return err;
-    }
-
-    // the difference between lookup and sublookup is we accept any tag
     if (tag_) {
         *tag_ = tag__;
     }
@@ -7557,7 +7497,7 @@ static int lfsr_mtree_lookupnext(lfs_t *lfs, lfsr_smid_t mid, lfsr_tag_t tag,
 }
 
 static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, lfsr_tag_t tag,
-        lfsr_mdir_t *mdir_, lfsr_data_t *data_) {
+        lfsr_mdir_t *mdir_, lfsr_tag_t *tag_, lfsr_data_t *data_) {
     lfsr_mdir_t mdir;
     int err = lfsr_mtree_lookupleaf(lfs, mid,
             &mdir);
@@ -7566,7 +7506,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, lfsr_tag_t tag,
     }
 
     err = lfsr_mdir_lookup(lfs, &mdir, tag,
-            data_);
+            tag_, data_);
     if (err) {
         return err;
     }
@@ -7839,7 +7779,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                     lfsr_data_t data;
                     int err = lfsr_mdir_lookup(lfs, mdir,
                             LFSR_TAG_ATTR(attrs_[j].type),
-                            &data);
+                            NULL, &data);
                     if (err && err != LFS_ERR_NOENT) {
                         return err;
                     }
@@ -8321,7 +8261,7 @@ static int lfsr_mroot_parent(lfs_t *lfs, const lfs_block_t mptr[static 2],
         // lookup next mroot
         lfsr_data_t data;
         err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_MROOT,
-                &data);
+                NULL, &data);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
             return err;
@@ -8550,7 +8490,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         // note we need to do this after playing out pending rattrs in
         // case they introduce a new name!
         lfsr_data_t split_name;
-        err = lfsr_rbyd_sublookup(lfs, &mdir_[1].rbyd, 0, LFSR_TAG_NAME,
+        err = lfsr_rbyd_lookup(lfs, &mdir_[1].rbyd, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_NAME,
                 NULL, &split_name);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -8715,7 +8656,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         err = lfsr_mdir_commit_(lfs, &mroot_, -2, 0, NULL,
                 -1, LFSR_RATTRS(
                     LFSR_RATTR_BTREE(
-                        LFSR_TAG_SUB | LFSR_TAG_MTREE, 0,
+                        LFSR_TAG_MASK8 | LFSR_TAG_MTREE, 0,
                         &mtree_),
                     // were we committing to the mroot? include any -1 rattrs
                     (mdir->mid == -1)
@@ -9209,7 +9150,7 @@ static int lfsr_mtree_pathlookup(lfs_t *lfs, const char **path,
         if (mdir.mid != -1) {
             lfsr_data_t data;
             int err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_DID,
-                    &data);
+                    NULL, &data);
             if (err) {
                 return err;
             }
@@ -9324,7 +9265,8 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t,
             // lookup mroot, if we find one this is not the active mroot
             lfsr_tag_t tag;
             lfsr_data_t data;
-            err = lfsr_mdir_sublookup(lfs, &t->b.o.mdir, LFSR_TAG_STRUCT,
+            err = lfsr_mdir_lookup(lfs, &t->b.o.mdir,
+                    LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
                     &tag, &data);
             if (err) {
                 // if we have no mtree (inlined mdir), we need to
@@ -10188,7 +10130,7 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) {
     lfs_alloc_ckpoint(lfs);
     err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_SUP | LFSR_TAG_DIR, (!exists) ? +1 : 0,
+                LFSR_TAG_MASK12 | LFSR_TAG_DIR, (!exists) ? +1 : 0,
                 did, path, name_len),
             LFSR_RATTR_LEB128(
                 LFSR_TAG_DID, 0, did_)));
@@ -10247,7 +10189,8 @@ static int lfsr_grm_pushdid(lfs_t *lfs, lfsr_did_t did) {
     }
 
     lfsr_data_t data;
-    err = lfsr_mdir_sublookup(lfs, &bookmark_mdir, LFSR_TAG_NAME,
+    err = lfsr_mdir_lookup(lfs, &bookmark_mdir,
+            LFSR_TAG_MASK8 | LFSR_TAG_NAME,
             NULL, &data);
     if (err) {
         LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -10309,7 +10252,7 @@ int lfsr_remove(lfs_t *lfs, const char *path) {
         // first lets figure out the did
         lfsr_data_t data;
         err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_DID,
-                &data);
+                NULL, &data);
         if (err) {
             return err;
         }
@@ -10338,7 +10281,7 @@ int lfsr_remove(lfs_t *lfs, const char *path) {
             // and trim the entry size
             (zombie)
                 ? LFSR_RATTR_NAME(
-                    LFSR_TAG_SUP | LFSR_TAG_STICKYNOTE, 0,
+                    LFSR_TAG_MASK12 | LFSR_TAG_STICKYNOTE, 0,
                     did, path, lfsr_path_namelen(path))
                 : LFSR_RATTR(
                     LFSR_TAG_RM, -1)));
@@ -10479,7 +10422,7 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) {
             // first lets figure out the did
             lfsr_data_t data;
             err = lfsr_mdir_lookup(lfs, &new_mdir, LFSR_TAG_DID,
-                    &data);
+                    NULL, &data);
             if (err) {
                 return err;
             }
@@ -10505,7 +10448,7 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) {
     lfs_alloc_ckpoint(lfs);
     err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_SUP | old_tag, (!exists) ? +1 : 0,
+                LFSR_TAG_MASK12 | old_tag, (!exists) ? +1 : 0,
                 new_did, new_path, new_name_len),
             LFSR_RATTR_MOVE(&old_mdir)));
     if (err) {
@@ -10682,7 +10625,7 @@ int lfsr_dir_open(lfs_t *lfs, lfsr_dir_t *dir, const char *path) {
 
         lfsr_data_t data;
         err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_DID,
-                &data);
+                NULL, &data);
         if (err) {
             return err;
         }
@@ -10750,7 +10693,8 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info) {
         // lookup the next name tag
         lfsr_tag_t tag;
         lfsr_data_t data;
-        int err = lfsr_mdir_sublookup(lfs, &dir->o.mdir, LFSR_TAG_NAME,
+        int err = lfsr_mdir_lookup(lfs, &dir->o.mdir,
+                LFSR_TAG_MASK8 | LFSR_TAG_NAME,
                 &tag, &data);
         if (err) {
             return err;
@@ -10888,7 +10832,7 @@ static int lfsr_lookupattr(lfs_t *lfs, const char *path, uint8_t type,
 
     // lookup our attr
     err = lfsr_mdir_lookup(lfs, mdir_, LFSR_TAG_ATTR(type),
-            data_);
+            NULL, data_);
     if (err) {
         if (err == LFS_ERR_NOENT) {
             return LFS_ERR_NOATTR;
@@ -11119,7 +11063,7 @@ static int lfsr_file_fetch(lfs_t *lfs, lfsr_file_t *file, bool trunc) {
         lfsr_data_t data;
         int err = lfsr_mdir_lookup(lfs, &file->b.o.mdir,
                 LFSR_TAG_ATTR(file->cfg->attrs[i].type),
-                &data);
+                NULL, &data);
         if (err && err != LFS_ERR_NOENT) {
             return err;
         }
@@ -11680,7 +11624,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
             
             err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS(
                     LFSR_RATTR_DATA(
-                        LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA,
+                        LFSR_TAG_GROW | LFSR_TAG_MASK8 | LFSR_TAG_DATA,
                             -(weight_ - lfs->cfg->fragment_size),
                         &LFSR_DATA_TRUNCATE(l.data,
                                 lfs->cfg->fragment_size)),
@@ -11709,7 +11653,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
 
             err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS(
                     LFSR_RATTR_BPTR(
-                        LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK,
+                        LFSR_TAG_GROW | LFSR_TAG_MASK8 | LFSR_TAG_BLOCK,
                             -(weight_ - lfsr_data_size(bptr_.data)),
                         &bptr_),
                     LFSR_RATTR_DATA(
@@ -11738,14 +11682,14 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
             // carve fragment?
             } else if (!lfsr_bptr_isbptr(&bptr_)) {
                 rattrs[rattr_count++] = LFSR_RATTR_DATA(
-                        LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA,
+                        LFSR_TAG_GROW | LFSR_TAG_MASK8 | LFSR_TAG_DATA,
                             -(bid+1 - pos),
                         &l.data);
 
             // carve bptr?
             } else {
                 rattrs[rattr_count++] = LFSR_RATTR_BPTR(
-                        LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK,
+                        LFSR_TAG_GROW | LFSR_TAG_MASK8 | LFSR_TAG_BLOCK,
                             -(bid+1 - pos),
                         &l);
             }
@@ -12575,7 +12519,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
         LFS_ASSERT(lfsr_o_isunsync(file->b.o.flags));
 
         err = lfsr_mdir_lookup(lfs, &file->b.o.mdir, LFSR_TAG_STICKYNOTE,
-                &name_data);
+                NULL, &name_data);
         if (err) {
             // orphan flag but no stickynote tag?
             LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -12583,7 +12527,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
         }
 
         rattrs[rattr_count++] = LFSR_RATTR_DATA(
-                LFSR_TAG_SUB | LFSR_TAG_REG, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_REG, 0,
                 &name_data);
     }
 
@@ -12602,17 +12546,17 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
         // no bshrub/btree?
         if (lfsr_bshrub_isbnull(&file->b)) {
             rattrs[rattr_count++] = LFSR_RATTR(
-                    LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_STRUCT, 0);
+                    LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, 0);
         // bshrub?
         } else if (lfsr_bshrub_isbshrub(&file->b)) {
             rattrs[rattr_count++] = LFSR_RATTR_SHRUB(
-                    LFSR_TAG_SUB | LFSR_TAG_BSHRUB, 0,
+                    LFSR_TAG_MASK8 | LFSR_TAG_BSHRUB, 0,
                     // note we use the staged trunk here
                     &file->b.shrub_);
         // btree?
         } else if (lfsr_bshrub_isbtree(&file->b)) {
             rattrs[rattr_count++] = LFSR_RATTR_BTREE(
-                    LFSR_TAG_SUB | LFSR_TAG_BTREE, 0,
+                    LFSR_TAG_MASK8 | LFSR_TAG_BTREE, 0,
                     &file->b.shrub);
         } else {
             LFS_UNREACHABLE();
@@ -12637,7 +12581,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
             lfsr_data_t data;
             err = lfsr_mdir_lookup(lfs, &file->b.o.mdir,
                     LFSR_TAG_ATTR(file->cfg->attrs[i].type),
-                    &data);
+                    NULL, &data);
             if (err && err != LFS_ERR_NOENT) {
                 goto failed;
             }
@@ -13538,7 +13482,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
     uint8_t version[2] = {0, 0};
     lfsr_data_t data;
     int err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_VERSION,
-            &data);
+            NULL, &data);
     if (err && err != LFS_ERR_NOENT) {
         return err;
     }
@@ -13564,7 +13508,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
     // the filesystem
     lfsr_rcompat_t rcompat = 0;
     err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_RCOMPAT,
-            &data);
+            NULL, &data);
     if (err && err != LFS_ERR_NOENT) {
         return err;
     }
@@ -13586,7 +13530,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
     // the filesystem
     lfsr_wcompat_t wcompat = 0;
     err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_WCOMPAT,
-            &data);
+            NULL, &data);
     if (err && err != LFS_ERR_NOENT) {
         return err;
     }
@@ -13613,7 +13557,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
     // check the on-disk geometry
     lfsr_geometry_t geometry;
     err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_GEOMETRY,
-            &data);
+            NULL, &data);
     if (err) {
         if (err == LFS_ERR_NOENT) {
             LFS_ERROR("No geometry found");
@@ -13648,7 +13592,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
     // read the name limit
     lfs_size_t name_limit = 0xff;
     err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_NAMELIMIT,
-            &data);
+            NULL, &data);
     if (err && err != LFS_ERR_NOENT) {
         return err;
     }
@@ -13674,7 +13618,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
     // read the file limit
     lfs_off_t file_limit = 0x7fffffff;
     err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_FILELIMIT,
-            &data);
+            NULL, &data);
     if (err && err != LFS_ERR_NOENT) {
         return err;
     }
@@ -13757,7 +13701,7 @@ static int lfsr_mountinited(lfs_t *lfs) {
                 // check for the magic string, all mroot should have this
                 lfsr_data_t data;
                 err = lfsr_mdir_lookup(lfs, mdir, LFSR_TAG_MAGIC,
-                        &data);
+                        NULL, &data);
                 if (err) {
                     if (err == LFS_ERR_NOENT) {
                         LFS_ERROR("No littlefs magic found");
@@ -13778,7 +13722,7 @@ static int lfsr_mountinited(lfs_t *lfs) {
 
                 // are we the last mroot?
                 err = lfsr_mdir_lookup(lfs, mdir, LFSR_TAG_MROOT,
-                        NULL);
+                        NULL, NULL);
                 if (err && err != LFS_ERR_NOENT) {
                     return err;
                 }
@@ -14277,7 +14221,7 @@ static int lfsr_mdir_mkconsistent(lfs_t *lfs, lfsr_mdir_t *mdir) {
 
         // is this mid marked as a stickynote?
         err = lfsr_mdir_lookup(lfs, mdir, LFSR_TAG_STICKYNOTE,
-                NULL);
+                NULL, NULL);
         if (err) {
             if (err == LFS_ERR_NOENT) {
                 mdir->mid += 1;
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index ccd329c6..26c7f45b 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -727,7 +727,7 @@ code = '''
     // update the tree
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "A", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -776,11 +776,11 @@ code = '''
     // update the tree
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "A", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "B", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -838,15 +838,15 @@ code = '''
     // update the tree
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "A", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "B", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "C", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -913,7 +913,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
                 LFSR_RATTR_BUF(
-                    LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                    LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                     &(uint8_t){'A'+(i % 26)}, 1))) => 0;
     }
     printf("btree: w%d 0x%x.%x\n",
@@ -986,7 +986,7 @@ code = '''
         // update btree
         lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
                 LFSR_RATTR_BUF(
-                    LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                    LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                     &(uint8_t){'A'+(i % 26)}, 1))) => 0;
 
         // update sim
@@ -1060,7 +1060,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_RATTRS(
                 LFSR_RATTR_BUF(
-                    LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                    LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                     &(uint8_t){'A'+(i % 26)}, 1))) => 0;
     }
     printf("btree: w%d 0x%x.%x\n",
@@ -1160,7 +1160,7 @@ code = '''
         lfsr_btree_commit(&lfs, &btree,
                 weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
                     LFSR_RATTR_BUF(
-                        LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                        LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                         &(uint8_t){'A'+(i % 26)}, 1),
                     LFSR_RATTR(
                         LFSR_TAG_GROW, +weight-sim_weights[bid]))) => 0;
@@ -2492,7 +2492,7 @@ code = '''
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 buf2, SIZE))) => 0;
     assert(btree.weight == 2);
 
@@ -2561,7 +2561,7 @@ code = '''
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 buf2, SIZE))) => 0;
     assert(btree.weight == 2);
 
@@ -2698,18 +2698,18 @@ code = '''
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 buf2, SIZE))) => 0;
     assert(btree.weight == 2);
 
     // now make both entries small so they should be merged if either compacts
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "a", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                 "b", 1))) => 0;
 
     // force compaction, while removing one entry, this drops the rbyd
@@ -2794,7 +2794,7 @@ code = '''
             // update btree
             lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
                     LFSR_RATTR_BUF(
-                        LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                        LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                         &(uint8_t){'a'+(i % 26)}, 1))) => 0;
 
             // update sim
@@ -2916,7 +2916,7 @@ code = '''
             lfsr_btree_commit(&lfs, &btree,
                     weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
                         LFSR_RATTR_BUF(
-                            LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                            LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                             &(uint8_t){'a'+(i % 26)}, 1),
                         LFSR_RATTR(
                             LFSR_TAG_GROW, +weight-sim_weights[bid]))) => 0;
@@ -3855,7 +3855,7 @@ code = '''
             // update btree
             lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
                     LFSR_RATTR_BUF(
-                        LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                        LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                         &(uint8_t){'0'+(i % 10)}, 1))) => 0;
 
             // update sim
@@ -4028,7 +4028,7 @@ code = '''
             lfsr_btree_commit(&lfs, &btree,
                     weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
                         LFSR_RATTR_BUF(
-                            LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
+                            LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0,
                             &(uint8_t){'0'+(i % 10)}, 1),
                         LFSR_RATTR(
                             LFSR_TAG_GROW, +weight-sim_weights[bid]))) => 0;
diff --git a/tests/test_files.toml b/tests/test_files.toml
index bb84a8c9..b6a8d8b7 100644
--- a/tests/test_files.toml
+++ b/tests/test_files.toml
@@ -979,7 +979,7 @@ code = '''
     // delete any bshrub/btree
     lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS(
             LFSR_RATTR(
-                LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_STRUCT, 0))) => 0;
+                LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, 0))) => 0;
 
     lfsr_file_close(&lfs, &file) => 0;
 
@@ -1111,7 +1111,7 @@ code = '''
                     .rattr_count=1})))) => 0;
     lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS(
             LFSR_RATTR_SHRUB(
-                LFSR_TAG_SUB | LFSR_TAG_BSHRUB, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_BSHRUB, 0,
                 &file.b.shrub_))) => 0;
 
     lfsr_file_close(&lfs, &file) => 0;
@@ -1234,7 +1234,7 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
     lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS(
             LFSR_RATTR_BTREE(
-                LFSR_TAG_SUB | LFSR_TAG_BTREE, 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_BTREE, 0,
                 &file.b.shrub))) => 0;
 
     lfsr_file_close(&lfs, &file) => 0;
diff --git a/tests/test_mount.toml b/tests/test_mount.toml
index 916ef106..f3f58bba 100644
--- a/tests/test_mount.toml
+++ b/tests/test_mount.toml
@@ -1132,7 +1132,7 @@ code = '''
             &mdir, NULL, &did) => 0;
     lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
             LFSR_RATTR_CAT(
-                LFSR_TAG_SUB | (LFSR_TAG_NAME + 0x13), 0,
+                LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0,
                 lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}),
                 LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0;
     lfsr_unmount(&lfs) => 0;
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index c99543e6..b4d94d39 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -45,7 +45,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_data_t data;
         uint8_t buffer[1];
-        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), &data) => 0;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 1) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
@@ -59,7 +59,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_data_t data;
         uint8_t buffer[1];
-        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), &data) => 0;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 1) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
@@ -90,7 +90,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_data_t data;
         uint8_t buffer[1];
-        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), &data) => 0;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 1) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
@@ -104,7 +104,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_data_t data;
         uint8_t buffer[1];
-        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), &data) => 0;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 1) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
@@ -130,14 +130,14 @@ code = '''
         lfsr_data_t data;
 
         uint8_t buffer[4];
-        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 4) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
     lfsr_data_t data;
 
     uint8_t buffer[4];
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 1;
     assert(memcmp(buffer, &(uint8_t){'a'+((N-1) % 26)}, 1) == 0);
 
@@ -147,7 +147,7 @@ code = '''
     // check things stay sane after remount
     lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0;
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 1;
     assert(memcmp(buffer, &(uint8_t){'a'+((N-1) % 26)}, 1) == 0);
 
@@ -192,17 +192,17 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -216,17 +216,17 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -279,17 +279,17 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -305,17 +305,17 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -388,27 +388,27 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -424,27 +424,27 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -481,7 +481,7 @@ code = '''
         lfsr_data_t data;
 
         uint8_t buffer[256];
-        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
@@ -491,7 +491,7 @@ code = '''
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -502,7 +502,7 @@ code = '''
             lfsr_mtree_lookupleaf(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1,
                     &mdir) => 0;
         }
-        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
@@ -513,7 +513,7 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -524,7 +524,7 @@ code = '''
             lfsr_mtree_lookupleaf(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1,
                     &mdir) => 0;
         }
-        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
@@ -580,7 +580,7 @@ code = '''
 
         // double check
         uint8_t buffer[256];
-        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
@@ -590,7 +590,7 @@ code = '''
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -599,7 +599,7 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
@@ -614,7 +614,7 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -623,7 +623,7 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
@@ -698,11 +698,11 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -718,11 +718,11 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -790,11 +790,11 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -810,11 +810,11 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -873,7 +873,7 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
@@ -889,7 +889,7 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
@@ -967,17 +967,17 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
 
@@ -993,17 +993,17 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
 
@@ -1081,17 +1081,17 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -1107,17 +1107,17 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -1175,7 +1175,7 @@ code = '''
 
             // double check
             uint8_t buffer[256];
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
 
@@ -1207,7 +1207,7 @@ code = '''
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -1216,7 +1216,7 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
@@ -1231,7 +1231,7 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -1240,7 +1240,7 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
@@ -1309,27 +1309,27 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -1343,27 +1343,27 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -1437,27 +1437,27 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -1473,27 +1473,27 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -1567,27 +1567,27 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -1603,27 +1603,27 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -1670,15 +1670,15 @@ code = '''
     // assert that our entry is still in the mroot
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -1689,15 +1689,15 @@ code = '''
     // assert that our rattr is still in the mroot
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -1765,31 +1765,31 @@ code = '''
     // assert that our rattr is still in the mroot
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'f');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'g');
 
@@ -1800,31 +1800,31 @@ code = '''
     // assert that our rattr is still in the mroot
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'f');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'g');
 
@@ -1882,23 +1882,23 @@ code = '''
     // assert that our entry is still in the mroot
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -1909,23 +1909,23 @@ code = '''
     // assert that our rattr is still in the mroot
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -2004,27 +2004,27 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -2040,27 +2040,27 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
@@ -2146,31 +2146,31 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'f');
 
@@ -2186,31 +2186,31 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
     lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'e');
 
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'f');
 
@@ -2289,11 +2289,11 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -2309,11 +2309,11 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -2364,17 +2364,17 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -2388,17 +2388,17 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -2461,17 +2461,17 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -2487,17 +2487,17 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 1) => 1;
     assert(buffer[0] == 'c');
 
@@ -2557,7 +2557,7 @@ code = '''
 
             // double check
             uint8_t buffer[256];
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
 
@@ -2586,7 +2586,7 @@ code = '''
 
             // double check
             uint8_t buffer[256];
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
 
@@ -2618,7 +2618,7 @@ code = '''
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -2627,7 +2627,7 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
@@ -2642,7 +2642,7 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -2651,7 +2651,7 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
@@ -2702,7 +2702,7 @@ code = '''
 
     // assert our entry was created
     uint8_t buffer[2];
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 2) => 2;
     assert(buffer[1] == 'b');
 
@@ -3541,7 +3541,7 @@ code = '''
     uint8_t buffer[256];
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2;
     assert(memcmp(buffer, "\0a", 2) == 0);
 
@@ -3552,7 +3552,7 @@ code = '''
     // assert that our entry is still in the mtree
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2;
     assert(memcmp(buffer, "\0a", 2) == 0);
 
@@ -3659,13 +3659,13 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
@@ -3679,13 +3679,13 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
-    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
@@ -3804,13 +3804,13 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
@@ -3826,13 +3826,13 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
@@ -3970,19 +3970,19 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
@@ -3998,19 +3998,19 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
@@ -4114,7 +4114,7 @@ code = '''
     uint8_t buffer[256];
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2;
     assert(memcmp(buffer, "\0a", 2) == 0);
 
@@ -4125,7 +4125,7 @@ code = '''
     // assert that our entry is still in the mtree
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2;
     assert(memcmp(buffer, "\0a", 2) == 0);
 
@@ -4162,7 +4162,7 @@ code = '''
         lfsr_data_t data;
 
         uint8_t buffer[256];
-        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
@@ -4236,7 +4236,7 @@ code = '''
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -4247,7 +4247,7 @@ code = '''
             lfsr_mtree_lookupleaf(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1,
                     &mdir) => 0;
         }
-        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
@@ -4258,7 +4258,7 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -4269,7 +4269,7 @@ code = '''
             lfsr_mtree_lookupleaf(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1,
                     &mdir) => 0;
         }
-        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
@@ -4325,7 +4325,7 @@ code = '''
 
         // double check
         uint8_t buffer[256];
-        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
@@ -4400,7 +4400,7 @@ code = '''
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
     lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -4409,7 +4409,7 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
@@ -4424,7 +4424,7 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
@@ -4433,7 +4433,7 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
@@ -4803,7 +4803,7 @@ code = '''
     // assert that our entry is still in the mroot
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
@@ -4876,7 +4876,7 @@ code = '''
     // assert that our rattr is still in the mroot
     lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml
index 1c4ccb83..06ce8ca2 100644
--- a/tests/test_rbyd.toml
+++ b/tests/test_rbyd.toml
@@ -394,18 +394,18 @@ code = '''
                 LFSR_TAG_ATTR(1), 0,
                 "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // commit with two attributes
     rbyd = init_rbyd;
@@ -418,20 +418,20 @@ code = '''
                 LFSR_TAG_ATTR(2), 0,
                 "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
@@ -443,20 +443,20 @@ code = '''
             LFSR_RATTR_BUF(
                 LFSR_TAG_ATTR(1), 0,
                 "\xaa\xaa\xaa\xaa", 4))) => 0;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_get]
@@ -484,18 +484,18 @@ code = '''
                 LFSR_TAG_ATTR(1), 0,
                 "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // commit with two attributes
     rbyd = init_rbyd;
@@ -509,20 +509,20 @@ code = '''
                 LFSR_TAG_ATTR(2), 0,
                 "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
@@ -535,20 +535,20 @@ code = '''
             LFSR_RATTR_BUF(
                 LFSR_TAG_ATTR(1), 0,
                 "\xaa\xaa\xaa\xaa", 4))) => 0;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
-    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_bifoliate]
@@ -4059,7 +4059,7 @@ code = '''
     first = true;
     for (unsigned rattr = 0; rattr < N; rattr++) {
         int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(rattr),
-                &data);
+                NULL, &data);
         if (!err) {
             lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
             if (!first) {
@@ -4073,7 +4073,7 @@ code = '''
 
     for (unsigned rattr = 0; rattr < N; rattr++) {
         int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(rattr),
-                &data);
+                NULL, &data);
         if (sim[rattr]) {
             assert(err == 0);
             lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
@@ -4117,13 +4117,13 @@ code = '''
                 "\xaa\xaa\xaa\xaa", 4))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
@@ -4139,19 +4139,19 @@ code = '''
                 "\xbb\xbb\xbb\xbb", 4))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
@@ -4170,25 +4170,25 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 '''
@@ -4219,13 +4219,13 @@ code = '''
                 "\xaa\xaa\xaa\xaa", 4))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
@@ -4242,19 +4242,19 @@ code = '''
                 "\xbb\xbb\xbb\xbb", 4))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
@@ -4271,19 +4271,19 @@ code = '''
                 "\xaa\xaa\xaa\xaa", 4))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
@@ -4304,25 +4304,25 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
@@ -4343,25 +4343,25 @@ code = '''
                 "\xaa\xaa\xaa\xaa", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
@@ -4382,25 +4382,25 @@ code = '''
                 "\xbb\xbb\xbb\xbb", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 '''
@@ -4481,7 +4481,7 @@ code = '''
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd,
-                    j, LFSR_TAG_DATA, &data) => 0;
+                    j, LFSR_TAG_DATA, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
@@ -4546,7 +4546,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4554,7 +4554,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4566,7 +4566,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4574,7 +4574,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4620,7 +4620,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4628,7 +4628,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4640,7 +4640,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4648,7 +4648,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4671,7 +4671,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4679,7 +4679,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4691,7 +4691,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4699,7 +4699,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4789,7 +4789,7 @@ code = '''
             assert(rid_ == j);
             assert(lfsr_data_size(data_) == 4);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
@@ -4900,19 +4900,19 @@ code = '''
                 "\xaa\xaa",         2))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
@@ -4934,31 +4934,31 @@ code = '''
                 "\xbb\xbb",         2))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
@@ -4986,66 +4986,66 @@ code = '''
                 "\xcc\xcc",         2))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 '''
@@ -5080,19 +5080,19 @@ code = '''
                 "\xaa\xaa",         2))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
@@ -5117,31 +5117,31 @@ code = '''
                 "\xbb\xbb",         2))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
@@ -5166,31 +5166,31 @@ code = '''
                 "\xaa\xaa",         2))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
@@ -5223,66 +5223,66 @@ code = '''
                 "\xcc\xcc",         2))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
@@ -5315,43 +5315,43 @@ code = '''
                 "\xaa\xaa",         2))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
@@ -5384,43 +5384,43 @@ code = '''
                 "\xbb\xbb",         2))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 '''
@@ -5508,13 +5508,13 @@ code = '''
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
                 lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_ATTR(u+1),
-                        &data) => 0;
+                        NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                 assert(memcmp(buffer, names[j % 6], 2) == 0);
             }
@@ -5586,7 +5586,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5594,7 +5594,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5602,7 +5602,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5610,7 +5610,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5622,7 +5622,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5630,7 +5630,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5638,7 +5638,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5646,7 +5646,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5700,7 +5700,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5708,7 +5708,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5716,7 +5716,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5724,7 +5724,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5736,7 +5736,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5744,7 +5744,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5752,7 +5752,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5760,7 +5760,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5791,7 +5791,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5799,7 +5799,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5807,7 +5807,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5815,7 +5815,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5827,7 +5827,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5835,7 +5835,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5843,7 +5843,7 @@ code = '''
     assert(tag_ == LFSR_TAG_DATA);
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 4);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5851,7 +5851,7 @@ code = '''
     assert(tag_ == LFSR_TAG_ATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(data_) == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5950,7 +5950,7 @@ code = '''
             assert(rid_ == j);
             assert(lfsr_data_size(data_) == 4);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
@@ -5961,7 +5961,7 @@ code = '''
                 assert(rid_ == j);
                 assert(lfsr_data_size(data_) == 2);
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                 assert(memcmp(buffer, names[j % 6], 2) == 0);
             }
@@ -6072,13 +6072,13 @@ code = '''
         // check that all tags have been updated
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
                 lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_ATTR(u+1),
-                        &data) => 0;
+                        NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 3;
                 assert(memcmp(buffer, names[j % 6], 3) == 0);
             }
@@ -6219,7 +6219,7 @@ code = '''
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
-                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
@@ -6247,7 +6247,7 @@ code = '''
                         assert(rid_ == k);
                         assert(lfsr_data_size(data_) == 2);
 
-                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                         lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                         assert(memcmp(buffer, names[k % 6], 2) == 0);
                     }
@@ -6263,7 +6263,7 @@ code = '''
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
-                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
@@ -6276,7 +6276,7 @@ code = '''
                         assert(rid_ == k);
                         assert(lfsr_data_size(data_) == 3);
 
-                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                         lfsr_data_read(&lfs, &data, buffer, 4) => 3;
                         assert(memcmp(buffer, names[k % 6], 3) == 0);
                     } else {
@@ -6284,7 +6284,7 @@ code = '''
                         assert(rid_ == k);
                         assert(lfsr_data_size(data_) == 2);
 
-                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                         lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                         assert(memcmp(buffer, names[k % 6], 2) == 0);
                     }
@@ -6417,13 +6417,13 @@ code = '''
         // check that all tags have been removed
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
                 lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_ATTR(u+1),
-                        &data) => LFS_ERR_NOENT;
+                        NULL, &data) => LFS_ERR_NOENT;
             }
         }
 
@@ -6628,13 +6628,13 @@ code = '''
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd,
-                    -1, LFSR_TAG_ATTR(j+1), &data) => 0;
+                    -1, LFSR_TAG_ATTR(j+1), NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 1;
             assert(memcmp(buffer, names[j % 6], 1) == 0);
         }
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd,
-                    j, LFSR_TAG_DATA, &data) => 0;
+                    j, LFSR_TAG_DATA, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
@@ -6650,7 +6650,7 @@ code = '''
             assert(rid_ == -1);
             assert(lfsr_data_size(data_) == 1);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 1;
             assert(memcmp(buffer, names[j % 6], 1) == 0);
         }
@@ -6661,7 +6661,7 @@ code = '''
             assert(rid_ == j);
             assert(lfsr_data_size(data_) == 4);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
@@ -6780,18 +6780,18 @@ code = '''
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd,
-                    -1, LFSR_TAG_ATTR(j+1), &data) => 0;
+                    -1, LFSR_TAG_ATTR(j+1), NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 1;
             assert(memcmp(buffer, names[j % 6], 1) == 0);
         }
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
                 lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_ATTR(u+1),
-                        &data) => 0;
+                        NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                 assert(memcmp(buffer, names[j % 6], 2) == 0);
             }
@@ -6808,7 +6808,7 @@ code = '''
             assert(rid_ == -1);
             assert(lfsr_data_size(data_) == 1);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 1;
             assert(memcmp(buffer, names[j % 6], 1) == 0);
         }
@@ -6819,7 +6819,7 @@ code = '''
             assert(rid_ == j);
             assert(lfsr_data_size(data_) == 4);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
@@ -6830,7 +6830,7 @@ code = '''
                 assert(rid_ == j);
                 assert(lfsr_data_size(data_) == 2);
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                 assert(memcmp(buffer, names[j % 6], 2) == 0);
             }
@@ -6894,19 +6894,19 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to delete the other rid
     rbyd = init_rbyd;
@@ -6922,19 +6922,19 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to delete the largest of three
     rbyd = init_rbyd;
@@ -6953,23 +6953,23 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to delete the smallest of three
     rbyd = init_rbyd;
@@ -6988,23 +6988,23 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to delete the middle
     rbyd = init_rbyd;
@@ -7023,23 +7023,23 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range]
@@ -7079,29 +7079,29 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to delete the other rid
     rbyd = init_rbyd;
@@ -7123,29 +7123,29 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to delete the largest of three
     rbyd = init_rbyd;
@@ -7173,41 +7173,41 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to delete the smallest of three
     rbyd = init_rbyd;
@@ -7235,41 +7235,41 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to delete the middle
     rbyd = init_rbyd;
@@ -7297,41 +7297,41 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 # some additional delete range special cases
@@ -7428,101 +7428,101 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -7531,107 +7531,107 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range_r]
@@ -7720,89 +7720,89 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -7811,95 +7811,95 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range_y]
@@ -8016,125 +8016,125 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -8143,131 +8143,131 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range_rydy]
@@ -8375,119 +8375,119 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -8496,125 +8496,125 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range_rydy_backwards]
@@ -8722,119 +8722,119 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -8843,125 +8843,125 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range_rydye]
@@ -9070,107 +9070,107 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -9179,113 +9179,113 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range_rydye_backwards]
@@ -9394,107 +9394,107 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -9503,113 +9503,113 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range_dryy]
@@ -9761,149 +9761,149 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -9912,155 +9912,155 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range_dryy_backwards]
@@ -10210,149 +10210,149 @@ code = '''
             LFSR_RATTR(LFSR_TAG_RM, -1))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(10), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(10), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(11), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(11), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(12), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(12), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(13), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(13), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(14), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(14), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(10), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(10), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(11), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(11), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(12), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(12), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(13), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(13), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(14), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(14), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // try to recreate
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
@@ -10361,155 +10361,155 @@ code = '''
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(10), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(10), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(11), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(11), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(12), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(12), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(13), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(13), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(14), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(14), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(10), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(10), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(11), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(11), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(12), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(12), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(13), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(13), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
-    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(14), &data) => 0;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(14), NULL, &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xee\xee", 2) == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1),
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 # NOTE if we separate physical/logical block sizes we may be able to
@@ -10614,7 +10614,7 @@ code = '''
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
             for (unsigned k = 0; k < N-1; k++) {
-                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 if (k >= j) {
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
@@ -10623,7 +10623,7 @@ code = '''
                 }
             }
             lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_DATA,
-                    &data) => LFS_ERR_NOENT;
+                    NULL, &data) => LFS_ERR_NOENT;
 
             // try recreating the rid to make sure things still work
             printf("--- create: %d ---\n", j);
@@ -10637,11 +10637,11 @@ code = '''
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
                 } else {
-                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
@@ -10783,7 +10783,7 @@ code = '''
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
             for (unsigned k = 0; k < N-1; k++) {
-                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 if (k >= j) {
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
@@ -10793,7 +10793,7 @@ code = '''
 
                 for (unsigned u = 0; u < M; u++) {
                     lfsr_rbyd_lookup(&lfs, &rbyd,
-                            k, LFSR_TAG_ATTR(u+1), &data) => 0;
+                            k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                     if (k >= j) {
                         assert(memcmp(buffer, names[(k+1) % 6], 2) == 0);
@@ -10803,9 +10803,9 @@ code = '''
                 }
             }
             lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_DATA,
-                    &data) => LFS_ERR_NOENT;
+                    NULL, &data) => LFS_ERR_NOENT;
             lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_ATTR(1),
-                    &data) => LFS_ERR_NOENT;
+                    NULL, &data) => LFS_ERR_NOENT;
 
             // try recreating the rid to make sure things still work
             printf("--- create: %d ---\n", j);
@@ -10825,24 +10825,24 @@ code = '''
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
 
                     for (unsigned u = 0; u < M; u++) {
                         lfsr_rbyd_lookup(&lfs, &rbyd,
-                                k, LFSR_TAG_ATTR(u+1), &data) => 0;
+                                k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
                         lfsr_data_read(&lfs, &data, buffer, 6) => 3;
                         assert(memcmp(buffer, names[k % 6], 3) == 0);
                     }
                 } else {
-                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
 
                     for (unsigned u = 0; u < M; u++) {
                         lfsr_rbyd_lookup(&lfs, &rbyd,
-                                k, LFSR_TAG_ATTR(u+1), &data) => 0;
+                                k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
                         lfsr_data_read(&lfs, &data, buffer, 6) => 2;
                         assert(memcmp(buffer, names[k % 6], 2) == 0);
                     }
@@ -10986,7 +10986,7 @@ code = '''
                 assert(rid_ == k);
                 assert(lfsr_data_size(data_) == 4);
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 if (k >= j) {
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
@@ -11123,7 +11123,7 @@ code = '''
                 assert(rid_ == k);
                 assert(lfsr_data_size(data_) == 4);
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 if (k >= j) {
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
@@ -11138,7 +11138,7 @@ code = '''
                     assert(rid_ == k);
                     assert(lfsr_data_size(data_) == 2);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                     if (k >= j) {
                         assert(memcmp(buffer, names[(k+1) % 6], 2) == 0);
@@ -11187,12 +11187,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // create and delete two ids
     rbyd = init_rbyd;
@@ -11210,12 +11210,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // create and delete two ids in the other order
     rbyd = init_rbyd;
@@ -11234,12 +11234,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // create and delete three ids
     rbyd = init_rbyd;
@@ -11261,12 +11261,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // create and delete three ids in the other order
     rbyd = init_rbyd;
@@ -11290,12 +11290,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
 '''
 
@@ -11330,12 +11330,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // create and delete two ids
     rbyd = init_rbyd;
@@ -11359,12 +11359,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // create and delete two ids in the other order
     rbyd = init_rbyd;
@@ -11389,12 +11389,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // create and delete three ids
     rbyd = init_rbyd;
@@ -11425,12 +11425,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     // create and delete three ids in the other order
     rbyd = init_rbyd;
@@ -11463,12 +11463,12 @@ code = '''
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
-            &data) => LFS_ERR_NOENT;
+            NULL, &data) => LFS_ERR_NOENT;
 '''
 
 # NOTE if we separate physical/logical block sizes we may be able to
@@ -11575,7 +11575,7 @@ code = '''
         assert(rbyd.weight == 0);
         lfsr_rbyd_lookup(&lfs, &rbyd,
                 LFSR_TAG_DATA, 0,
-                &data) => LFS_ERR_NOENT;
+                NULL, &data) => LFS_ERR_NOENT;
 
         // try resuming from all tags being removed
         lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
@@ -11587,12 +11587,12 @@ code = '''
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 1);
         lfsr_rbyd_lookup(&lfs, &rbyd,
-                0, LFSR_TAG_DATA, &data) => 0;
+                0, LFSR_TAG_DATA, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 6) => 6;
         assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0);
         lfsr_rbyd_lookup(&lfs, &rbyd,
                 1, LFSR_TAG_DATA,
-                &data) => LFS_ERR_NOENT;
+                NULL, &data) => LFS_ERR_NOENT;
 
         // keep track of the worst size
         if (lfsr_rbyd_eoff(&rbyd) > worst_size) {
@@ -11731,7 +11731,7 @@ code = '''
         assert(rbyd.weight == 0);
         lfsr_rbyd_lookup(&lfs, &rbyd,
                 0, LFSR_TAG_DATA,
-                &data) => LFS_ERR_NOENT;
+                NULL, &data) => LFS_ERR_NOENT;
 
         // try resuming from all tags being removed
         lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
@@ -11749,21 +11749,21 @@ code = '''
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 1);
         lfsr_rbyd_lookup(&lfs, &rbyd,
-                0, LFSR_TAG_DATA, &data) => 0;
+                0, LFSR_TAG_DATA, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 6) => 6;
         assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0);
         for (unsigned u = 0; u < M; u++) {
             lfsr_rbyd_lookup(&lfs, &rbyd,
-                    0, LFSR_TAG_ATTR(u+1), &data) => 0;
+                    0, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 6) => 3;
             assert(memcmp(buffer, "\xaa\xaa\xaa", 3) == 0);
         }
         lfsr_rbyd_lookup(&lfs, &rbyd,
                 1, LFSR_TAG_DATA,
-                &data) => LFS_ERR_NOENT;
+                NULL, &data) => LFS_ERR_NOENT;
         lfsr_rbyd_lookup(&lfs, &rbyd,
                 1, LFSR_TAG_ATTR(1),
-                &data) => LFS_ERR_NOENT;
+                NULL, &data) => LFS_ERR_NOENT;
 
         // keep track of the worst size
         if (lfsr_rbyd_eoff(&rbyd) > worst_size) {
@@ -11881,7 +11881,7 @@ code = '''
     printf("rbyd: [");
     for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)rbyd.weight; rid++) {
         int err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA,
-                &data);
+                NULL, &data);
         if (!err) {
             lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
             printf("%.*s", size, buffer);
@@ -11896,7 +11896,7 @@ code = '''
 
     assert(count == rbyd.weight);
     for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) {
-        lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA, &data) => 0;
+        lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 4) => 1;
         assert(memcmp(&sim[rid], buffer, 1) == 0);
     }
@@ -12349,7 +12349,7 @@ code = '''
             assert(weight_ == W);
             assert(lfsr_data_size(data_) == 4);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
@@ -12442,7 +12442,7 @@ code = '''
             assert(weight_ == W);
             assert(lfsr_data_size(data_) == 4);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
@@ -13559,7 +13559,7 @@ code = '''
             assert(weight_ == 0);
             assert(lfsr_data_size(data_) == 2);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
@@ -13671,7 +13671,7 @@ code = '''
             assert(weight_ == W);
             assert(lfsr_data_size(data_) == 4);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
             lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
@@ -13820,7 +13820,7 @@ code = '''
                     assert(lfsr_data_size(data_) == 4);
                 }
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
             }
@@ -13939,7 +13939,7 @@ code = '''
                     assert(weight_ == W+D);
                     assert(lfsr_data_size(data_) == 6);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
                 } else if (k > j) {
@@ -13950,7 +13950,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else {
@@ -13961,7 +13961,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
@@ -14084,7 +14084,7 @@ code = '''
                     assert(weight_ == W+D);
                     assert(lfsr_data_size(data_) == 6);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
 
@@ -14096,7 +14096,7 @@ code = '''
                     assert(weight_ == 0);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else if (k > j) {
@@ -14108,7 +14108,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else {
@@ -14120,7 +14120,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
@@ -14253,7 +14253,7 @@ code = '''
                     assert(lfsr_data_size(data_) == 4);
                 }
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
             }
@@ -14372,7 +14372,7 @@ code = '''
                     assert(weight_ == W-D);
                     assert(lfsr_data_size(data_) == 6);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
                 } else if (k > j) {
@@ -14383,7 +14383,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else {
@@ -14394,7 +14394,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
@@ -14517,7 +14517,7 @@ code = '''
                     assert(weight_ == W-D);
                     assert(lfsr_data_size(data_) == 6);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
 
@@ -14529,7 +14529,7 @@ code = '''
                     assert(weight_ == 0);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else if (k > j) {
@@ -14541,7 +14541,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else {
@@ -14553,7 +14553,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
@@ -14670,7 +14670,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
                 } else {
@@ -14681,7 +14681,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
@@ -14706,7 +14706,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 6);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
                 } else {
@@ -14717,7 +14717,7 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(data_) == 4);
 
-                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                     lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
@@ -14836,7 +14836,7 @@ code = '''
                 assert(weight_ == W);
                 assert(lfsr_data_size(data_) == 4);
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
@@ -14868,13 +14868,13 @@ code = '''
                 assert(weight_ == W);
                 assert(lfsr_data_size(data_) == 4);
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
                 if (k == j) {
                     lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_ATTR(1),
-                            &data) => LFS_ERR_NOENT;
+                            NULL, &data) => LFS_ERR_NOENT;
                 }
             }
 
@@ -14896,7 +14896,7 @@ code = '''
                 assert(weight_ == W);
                 assert(lfsr_data_size(data_) == 4);
 
-                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
                 lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
@@ -15043,7 +15043,7 @@ code = '''
     printf("rbyd: [");
     for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)rbyd.weight; rid++) {
         int err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA,
-                &data);
+                NULL, &data);
         if (!err) {
             lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
             printf("%.*s", size, buffer);
@@ -15052,7 +15052,7 @@ code = '''
         }
         for (uint8_t u = 0; u < M; u++) {
             err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_ATTR(u),
-                    &data);
+                    NULL, &data);
             if (!err) {
                 lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
                 printf("%.*s", size, buffer);
@@ -15068,7 +15068,7 @@ code = '''
 
     assert(count == rbyd.weight);
     for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) {
-        lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA, &data) => 0;
+        lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 4) => 1;
         assert(memcmp(&sim[rid*(M+1)], buffer, 1) == 0);
     }
@@ -15258,7 +15258,7 @@ code = '''
         lfsr_rbyd_lookupnext(&lfs, &rbyd,
                 weighted_rid, LFSR_TAG_DATA,
                 &rid_, &tag_, &weight_, &data_) => 0;
-        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
         lfsr_data_read(&lfs, &data, buffer, 4) => 1;
         assert(memcmp(&sim[rid], buffer, 1) == 0);
     }
@@ -15349,7 +15349,7 @@ code = '''
         for (unsigned j = 0; j < N; j++) {
             lfsr_tag_t tag_;
             lfsr_data_t data_;
-            lfsr_rbyd_sublookup(&lfs, &rbyd, j, LFSR_TAG_ATTR,
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                     &tag_, &data_) => 0;
 
             assert(tag_ == LFSR_TAG_ATTR((j + SHIFT) & 0x7f));
@@ -15454,7 +15454,7 @@ code = '''
             // remove with a wide tag
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
                     LFSR_RATTR(
-                        LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0))) => 0;
+                        LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_ATTR, 0))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -15485,10 +15485,12 @@ code = '''
             // also test that we can lookup each tag with a wide lookup
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k,
+                            LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => LFS_ERR_NOENT;
                 } else {
-                    lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k,
+                            LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => 0;
                     assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f));
                     assert(lfsr_data_size(data_) == 2);
@@ -15597,7 +15599,7 @@ code = '''
             // replace with bitwise inverse
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
                     LFSR_RATTR_BUF(
-                        LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
+                        LFSR_TAG_MASK8 | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
                             0,
                         names[j % 6], 3))) => 0;
 
@@ -15634,7 +15636,7 @@ code = '''
 
             // also test that we can lookup each tag with a wide lookup
             for (unsigned k = 0; k < N; k++) {
-                lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                         &tag_, &data_) => 0;
                 if (k == j) {
                     assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f));
@@ -15731,7 +15733,7 @@ code = '''
         for (unsigned j = 0; j < N; j++) {
             lfsr_tag_t tag_;
             lfsr_data_t data_;
-            lfsr_rbyd_sublookup(&lfs, &rbyd, j, LFSR_TAG_ATTR,
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                     &tag_, &data_) => 0;
 
             assert(tag_ == LFSR_TAG_ATTR(0x7f & (j + SHIFT)));
@@ -15839,7 +15841,7 @@ code = '''
             // remove with a wide tag
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
                     LFSR_RATTR(
-                        LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0))) => 0;
+                        LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_ATTR, 0))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -15877,10 +15879,12 @@ code = '''
             // also test that we can lookup each tag with a wide lookup
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k,
+                            LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => LFS_ERR_NOENT;
                 } else {
-                    lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k,
+                            LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => 0;
                     assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f));
                     assert(lfsr_data_size(data_) == 2);
@@ -15992,7 +15996,7 @@ code = '''
             // replace with bitwise inverse
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
                     LFSR_RATTR_BUF(
-                        LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
+                        LFSR_TAG_MASK8 | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
                             0,
                         names[j % 6], 3))) => 0;
 
@@ -16036,7 +16040,7 @@ code = '''
 
             // also test that we can lookup each tag with a wide lookup
             for (unsigned k = 0; k < N; k++) {
-                lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                         &tag_, &data_) => 0;
                 if (k == j) {
                     assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f));
@@ -16127,7 +16131,7 @@ code = '''
         for (unsigned j = 0; j < N; j++) {
             lfsr_tag_t tag_;
             lfsr_data_t data_;
-            lfsr_rbyd_sublookup(&lfs, &rbyd, j, LFSR_TAG_ATTR,
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                     &tag_, &data_) => 0;
 
             assert(tag_ == LFSR_TAG_ATTR((j + SHIFT) & 0x7f));
@@ -16229,7 +16233,7 @@ code = '''
             // remove with a wide tag
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
                     LFSR_RATTR(
-                        LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0))) => 0;
+                        LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_ATTR, 0))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -16263,10 +16267,10 @@ code = '''
             // also test that we can lookup each tag with a wide lookup
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => LFS_ERR_NOENT;
                 } else {
-                    lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => 0;
                     assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f));
                     assert(lfsr_data_size(data_) == 4);
@@ -16372,7 +16376,7 @@ code = '''
             // replace with bitwise inverse
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
                     LFSR_RATTR_BUF(
-                        LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
+                        LFSR_TAG_MASK8 | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
                             0,
                         names[j % 6], 6))) => 0;
 
@@ -16402,7 +16406,7 @@ code = '''
 
             // also test that we can lookup each tag with a wide lookup
             for (unsigned k = 0; k < N; k++) {
-                lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                         &tag_, &data_) => 0;
                 if (k == j) {
                     assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f));
@@ -16497,7 +16501,7 @@ code = '''
         for (unsigned j = 0; j < N; j++) {
             lfsr_tag_t tag_;
             lfsr_data_t data_;
-            lfsr_rbyd_suplookup(&lfs, &rbyd, j,
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_MASK12,
                     &tag_, &data_) => 0;
 
             assert(tag_ == LFSR_TAG_DATA);
@@ -16602,7 +16606,8 @@ code = '''
             // remove with a wide tag
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
                     LFSR_RATTR(
-                        LFSR_TAG_RM | LFSR_TAG_SUP | LFSR_TAG_ATTR, 0))) => 0;
+                        LFSR_TAG_RM | LFSR_TAG_MASK12 | LFSR_TAG_ATTR,
+                        0))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -16633,10 +16638,10 @@ code = '''
             // also test that we can lookup each tag with a wide lookup
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => LFS_ERR_NOENT;
                 } else {
-                    lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => 0;
                     assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f));
                     assert(lfsr_data_size(data_) == 2);
@@ -16745,7 +16750,7 @@ code = '''
             // replace with bitwise inverse
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
                     LFSR_RATTR_BUF(
-                        LFSR_TAG_SUP | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
+                        LFSR_TAG_MASK12 | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
                             0,
                         names[j % 6], 3))) => 0;
 
@@ -16785,7 +16790,7 @@ code = '''
 
             // also test that we can lookup each tag with a wide lookup
             for (unsigned k = 0; k < N; k++) {
-                lfsr_rbyd_sublookup(&lfs, &rbyd, k, LFSR_TAG_ATTR,
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                         &tag_, &data_) => 0;
                 if (k == j) {
                     assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f));
@@ -17005,7 +17010,7 @@ code = '''
     // subwide replace a neighbor to the hole
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUB | LFSR_TAG_ATTR(0x02), 0,
+                LFSR_TAG_MASK8 | LFSR_TAG_ATTR(0x02), 0,
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
     assert(rbyd.weight == 0);
 
@@ -17073,7 +17078,7 @@ code = '''
     // supwide replace a neighbor to the hole
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
             LFSR_RATTR_BUF(
-                LFSR_TAG_SUP | LFSR_TAG_ATTR(2), 0,
+                LFSR_TAG_MASK12 | LFSR_TAG_ATTR(2), 0,
                 "\xcc\xcc\xcc\xcc", 4))) => 0;
     assert(rbyd.weight == 1);