diff --git a/lfs.c b/lfs.c
index 5a7ba125..88895b9c 100644
--- a/lfs.c
+++ b/lfs.c
@@ -1104,6 +1104,7 @@ enum lfsr_tag {
     LFSR_TAG_GEOMETRY       = 0x0038,
     LFSR_TAG_FILELIMIT      = 0x0039,
     LFSR_TAG_NAMELIMIT      = 0x003a,
+    // in-device only, to help find unknown config tags
     LFSR_TAG_UNKNOWNCONFIG  = 0x003b,
 
     // global-state tags
@@ -1112,15 +1113,17 @@ enum lfsr_tag {
 
     // name tags
     LFSR_TAG_NAME           = 0x0200,
+    LFSR_TAG_BNAME          = 0x0200,
     LFSR_TAG_REG            = 0x0201,
     LFSR_TAG_DIR            = 0x0202,
     LFSR_TAG_STICKYNOTE     = 0x0203,
     LFSR_TAG_BOOKMARK       = 0x0204,
-
     // in-device only name tags, these should never get written to disk
     LFSR_TAG_ORPHAN         = 0x0205,
     LFSR_TAG_TRAVERSAL      = 0x0206,
     LFSR_TAG_UNKNOWN        = 0x0207,
+    // non-file name tags
+    LFSR_TAG_MNAME          = 0x0220,
 
     // struct tags
     LFSR_TAG_STRUCT         = 0x0300,
@@ -3336,7 +3339,7 @@ static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
 }
 
 
-// finds the next rid+tag such that rid_+tag_ >= rid+tag
+// finds the next rid_+tag_ such that rid_+tag_ >= rid+tag
 static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
         lfsr_srid_t rid, lfsr_tag_t tag,
         lfsr_srid_t *rid_, lfsr_tag_t *tag_, lfsr_rid_t *weight_,
@@ -5247,6 +5250,8 @@ static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree,
     lfsr_srid_t rid = bid;
     while (true) {
         // each branch is a pair of optional name + on-disk structure
+
+        // lookup our bid in the rbyd
         lfsr_srid_t rid__;
         lfsr_tag_t tag__;
         lfsr_rid_t weight__;
@@ -5257,9 +5262,9 @@ static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree,
             return err;
         }
 
-        if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
-            err = lfsr_rbyd_lookup(lfs, &branch, rid__,
-                    LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        // if we found a bname, lookup the branch
+        if (tag__ == LFSR_TAG_BNAME) {
+            err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_BRANCH,
                     &tag__, &data__);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5366,9 +5371,9 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree,
             return err;
         }
 
-        if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
-            err = lfsr_rbyd_lookup(lfs, &branch, rid__,
-                    LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        // if we found a bname, lookup the branch
+        if (tag__ == LFSR_TAG_BNAME) {
+            err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_BRANCH,
                     &tag__, &data__);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5522,7 +5527,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        goto recurse;
+        goto commit;
 
     compact:;
         // estimate our compacted size
@@ -5551,8 +5556,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                 lfsr_tag_t sibling_tag;
                 lfsr_rid_t sibling_weight;
                 lfsr_data_t sibling_data;
-                err = lfsr_rbyd_lookupnext(lfs, &parent,
-                        pid+1, LFSR_TAG_NAME,
+                err = lfsr_rbyd_lookupnext(lfs, &parent, pid+1, 0,
                         &sibling_rid, &sibling_tag, &sibling_weight,
                         &sibling_data);
                 if (err) {
@@ -5560,9 +5564,10 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                     return err;
                 }
 
-                if (sibling_tag == LFSR_TAG_NAME) {
-                    err = lfsr_rbyd_lookup(lfs, &parent, sibling_rid,
-                            LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+                // if we found a bname, lookup the branch
+                if (sibling_tag == LFSR_TAG_BNAME) {
+                    err = lfsr_rbyd_lookup(lfs, &parent,
+                            sibling_rid, LFSR_TAG_BRANCH,
                             &sibling_tag, &sibling_data);
                     if (err) {
                         LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5599,8 +5604,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                 lfsr_tag_t sibling_tag;
                 lfsr_rid_t sibling_weight;
                 lfsr_data_t sibling_data;
-                err = lfsr_rbyd_lookupnext(lfs, &parent,
-                        pid-rbyd_.weight, LFSR_TAG_NAME,
+                err = lfsr_rbyd_lookupnext(lfs, &parent, pid-rbyd_.weight, 0,
                         &sibling_rid, &sibling_tag, &sibling_weight,
                         &sibling_data);
                 if (err) {
@@ -5608,9 +5612,10 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                     return err;
                 }
 
-                if (sibling_tag == LFSR_TAG_NAME) {
-                    err = lfsr_rbyd_lookup(lfs, &parent, sibling_rid,
-                            LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+                // if we found a bname, lookup the branch
+                if (sibling_tag == LFSR_TAG_BNAME) {
+                    err = lfsr_rbyd_lookup(lfs, &parent,
+                            sibling_rid, LFSR_TAG_BRANCH,
                             &sibling_tag, &sibling_data);
                     if (err) {
                         LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5694,7 +5699,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        goto recurse;
+        goto commit;
 
     split:;
         // we should have something to split here
@@ -5819,7 +5824,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             if (rbyd__.weight == 0) {
                 rbyd__ = sibling;
             }
-            goto recurse;
+            goto commit;
         }
 
         // lookup first name in sibling to use as the split name
@@ -5827,7 +5832,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         // note we need to do this after playing out pending rattrs in case
         // they introduce a new name!
         lfsr_tag_t split_tag;
-        err = lfsr_rbyd_lookupnext(lfs, &sibling, 0, LFSR_TAG_NAME,
+        err = lfsr_rbyd_lookupnext(lfs, &sibling, 0, 0,
                 NULL, &split_tag, NULL, &bctx->split_name);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -5852,7 +5857,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                     branch_r.u.buffer, lfsr_data_size(branch_r));
             if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) {
                 bctx->rattrs[rattr_count_++] = LFSR_RATTR_DATA(
-                        LFSR_TAG_NAME, 0,
+                        LFSR_TAG_BNAME, 0,
                         &bctx->split_name);
             }
         // split root?
@@ -5874,7 +5879,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
                     branch_r.u.buffer, lfsr_data_size(branch_r));
             if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) {
                 bctx->rattrs[rattr_count_++] = LFSR_RATTR_DATA(
-                        LFSR_TAG_NAME, 0,
+                        LFSR_TAG_BNAME, 0,
                         &bctx->split_name);
             }
         }
@@ -5980,7 +5985,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         rid_ = pid + sibling.weight;
         continue;
 
-    recurse:;
+    commit:;
         // done?
         if (!lfsr_rbyd_trunk(&parent)) {
             *btree = rbyd__;
@@ -6097,26 +6102,30 @@ static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs,
     lfsr_rbyd_t branch = *btree;
     lfsr_bid_t bid = 0;
     while (true) {
+        // each branch is a pair of optional name + on-disk structure
+
         // lookup our name in the rbyd via binary search
         lfsr_srid_t rid__;
+        lfsr_tag_t tag__;
         lfsr_rid_t weight__;
+        lfsr_data_t data__;
         lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &branch,
                 did, name, name_len,
-                &rid__, NULL, &weight__, NULL);
+                &rid__, &tag__, &weight__, &data__);
         if (cmp < 0) {
             LFS_ASSERT(cmp != LFS_ERR_NOENT);
             return cmp;
         }
 
-        // the name may not match exactly, but indicates which branch to follow
-        lfsr_tag_t tag__;
-        lfsr_data_t data__;
-        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);
-            return err;
+        // if we found a bname, lookup the branch
+        if (tag__ == LFSR_TAG_BNAME) {
+            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);
+                return err;
+            }
         }
 
         // found another branch
@@ -6125,7 +6134,7 @@ static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs,
             bid += rid__ - (weight__-1);
 
             // fetch the next branch
-            err = lfsr_data_fetchbranch(lfs, &data__, weight__,
+            int err = lfsr_data_fetchbranch(lfs, &data__, weight__,
                     &branch);
             if (err < 0) {
                 return err;
@@ -6223,9 +6232,9 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree,
             return err;
         }
 
-        if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
-            err = lfsr_rbyd_lookup(lfs, bt->branch, rid__,
-                    LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+        // if we found a bname, lookup the branch
+        if (tag__ == LFSR_TAG_BNAME) {
+            err = lfsr_rbyd_lookup(lfs, bt->branch, rid__, LFSR_TAG_BRANCH,
                     &tag__, &data__);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -7648,16 +7657,31 @@ static int lfsr_mtree_lookupleaf(lfs_t *lfs, lfsr_smid_t mid,
     // look up mdir in actual mtree
     } else {
         lfsr_bid_t bid;
+        lfsr_rbyd_t rbyd;
+        lfsr_srid_t rid;
         lfsr_tag_t tag;
+        lfsr_bid_t weight;
         lfsr_data_t data;
-        int err = lfsr_btree_lookupnext(lfs, &lfs->mtree, mid,
-                &bid, &tag, NULL, &data);
+        int err = lfsr_btree_lookupleaf(lfs, &lfs->mtree, mid,
+                &bid, &rbyd, &rid, &tag, &weight, &data);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
             return err;
         }
         LFS_ASSERT((lfsr_sbid_t)bid == lfsr_mbid(lfs, mid));
-        LFS_ASSERT(tag == LFSR_TAG_MDIR);
+        LFS_ASSERT(weight == (lfsr_bid_t)(1 << lfs->mbits));
+        LFS_ASSERT(tag == LFSR_TAG_MNAME
+                || tag == LFSR_TAG_MDIR);
+
+        // if we found an mname, lookup the mdir
+        if (tag == LFSR_TAG_MNAME) {
+            err = lfsr_rbyd_lookup(lfs, &rbyd, rid, LFSR_TAG_MDIR,
+                    NULL, &data);
+            if (err) {
+                LFS_ASSERT(err != LFS_ERR_NOENT);
+                return err;
+            }
+        }
 
         // fetch mdir
         err = lfsr_data_fetchmdir(lfs, &data, mid,
@@ -8722,7 +8746,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                             LFSR_TAG_MDIR, +(1 << lfs->mbits),
                             mdir_[0].rbyd.blocks),
                         LFSR_RATTR_DATA(
-                            LFSR_TAG_NAME, +(1 << lfs->mbits),
+                            LFSR_TAG_MNAME, +(1 << lfs->mbits),
                             &split_name),
                         LFSR_RATTR_MPTR(
                             LFSR_TAG_MDIR, 0,
@@ -8742,7 +8766,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                             LFSR_TAG_MDIR, 0,
                             mdir_[0].rbyd.blocks),
                         LFSR_RATTR_DATA(
-                            LFSR_TAG_NAME, +(1 << lfs->mbits),
+                            LFSR_TAG_MNAME, +(1 << lfs->mbits),
                             &split_name),
                         LFSR_RATTR_MPTR(
                             LFSR_TAG_MDIR, 0,
@@ -9179,21 +9203,34 @@ static int lfsr_mtree_namelookupleaf(lfs_t *lfs,
     // lookup name in actual mtree
     } else {
         lfsr_bid_t bid;
+        lfsr_rbyd_t rbyd;
+        lfsr_srid_t rid;
         lfsr_tag_t tag;
         lfsr_bid_t weight;
         lfsr_data_t data;
-        lfs_scmp_t cmp = lfsr_btree_namelookup(lfs, &lfs->mtree,
+        lfs_scmp_t cmp = lfsr_btree_namelookupleaf(lfs, &lfs->mtree,
                 did, name, name_len,
-                &bid, &tag, &weight, &data);
+                &bid, &rbyd, &rid, &tag, &weight, &data);
         if (cmp < 0) {
             LFS_ASSERT(cmp != LFS_ERR_NOENT);
             return cmp;
         }
-        LFS_ASSERT(tag == LFSR_TAG_MDIR);
-        LFS_ASSERT(weight == (1U << lfs->mbits));
+        LFS_ASSERT(weight == (lfsr_bid_t)(1 << lfs->mbits));
+        LFS_ASSERT(tag == LFSR_TAG_MNAME
+                || tag == LFSR_TAG_MDIR);
+
+        // if we found an mname, lookup the mdir
+        if (tag == LFSR_TAG_MNAME) {
+            int err = lfsr_rbyd_lookup(lfs, &rbyd, rid, LFSR_TAG_MDIR,
+                    NULL, &data);
+            if (err) {
+                LFS_ASSERT(err != LFS_ERR_NOENT);
+                return err;
+            }
+        }
 
         // fetch mdir
-        int err = lfsr_data_fetchmdir(lfs, &data, bid-(weight-1),
+        int err = lfsr_data_fetchmdir(lfs, &data, bid-((1 << lfs->mbits)-1),
                 &mdir);
         if (err) {
             return err;
diff --git a/scripts/dbgbmap.py b/scripts/dbgbmap.py
index b5a104b2..7a254616 100755
--- a/scripts/dbgbmap.py
+++ b/scripts/dbgbmap.py
@@ -42,10 +42,12 @@ TAG_NAMELIMIT   = 0x003a    #  0x003a  v--- ---- --11 1-1-
 TAG_GDELTA      = 0x0100    ## 0x01tt  v--- ---1 -ttt ttrr
 TAG_GRMDELTA    = 0x0100    #  0x0100  v--- ---1 ---- ----
 TAG_NAME        = 0x0200    ## 0x02tt  v--- --1- -ttt tttt
+TAG_BNAME       = 0x0200    #  0x0200  v--- --1- ---- ----
 TAG_REG         = 0x0201    #  0x0201  v--- --1- ---- ---1
 TAG_DIR         = 0x0202    #  0x0202  v--- --1- ---- --1-
 TAG_STICKYNOTE  = 0x0203    #  0x0203  v--- --1- ---- --11
 TAG_BOOKMARK    = 0x0204    #  0x0204  v--- --1- ---- -1--
+TAG_MNAME       = 0x0220    #  0x0220  v--- --1- --1- ----
 TAG_STRUCT      = 0x0300    ## 0x03tt  v--- --11 -ttt ttrr
 TAG_BRANCH      = 0x0300    #  0x030r  v--- --11 ---- --rr
 TAG_DATA        = 0x0304    #  0x0304  v--- --11 ---- -1--
@@ -314,11 +316,12 @@ def tagrepr(tag, weight=None, size=None, *,
     elif (tag & 0x6f00) == TAG_NAME:
         return '%s%s%s%s' % (
                 'shrub' if tag & TAG_SHRUB else '',
-                'name' if (tag & 0xfff) == TAG_NAME
+                'bname' if (tag & 0xfff) == TAG_BNAME
                     else 'reg' if (tag & 0xfff) == TAG_REG
                     else 'dir' if (tag & 0xfff) == TAG_DIR
                     else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE
                     else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK
+                    else 'mname' if (tag & 0xfff) == TAG_MNAME
                     else 'name 0x%02x' % (tag & 0xff),
                 ' w%d' % weight if weight else '',
                 ' %s' % size if size is not None else '')
diff --git a/scripts/dbgbmapd3.py b/scripts/dbgbmapd3.py
index 7a597bde..b1797565 100755
--- a/scripts/dbgbmapd3.py
+++ b/scripts/dbgbmapd3.py
@@ -40,10 +40,12 @@ TAG_NAMELIMIT   = 0x003a    #  0x003a  v--- ---- --11 1-1-
 TAG_GDELTA      = 0x0100    ## 0x01tt  v--- ---1 -ttt ttrr
 TAG_GRMDELTA    = 0x0100    #  0x0100  v--- ---1 ---- ----
 TAG_NAME        = 0x0200    ## 0x02tt  v--- --1- -ttt tttt
+TAG_BNAME       = 0x0200    #  0x0200  v--- --1- ---- ----
 TAG_REG         = 0x0201    #  0x0201  v--- --1- ---- ---1
 TAG_DIR         = 0x0202    #  0x0202  v--- --1- ---- --1-
 TAG_STICKYNOTE  = 0x0203    #  0x0203  v--- --1- ---- --11
 TAG_BOOKMARK    = 0x0204    #  0x0204  v--- --1- ---- -1--
+TAG_MNAME       = 0x0220    #  0x0220  v--- --1- --1- ----
 TAG_STRUCT      = 0x0300    ## 0x03tt  v--- --11 -ttt ttrr
 TAG_BRANCH      = 0x0300    #  0x030r  v--- --11 ---- --rr
 TAG_DATA        = 0x0304    #  0x0304  v--- --11 ---- -1--
@@ -344,11 +346,12 @@ def tagrepr(tag, weight=None, size=None, *,
     elif (tag & 0x6f00) == TAG_NAME:
         return '%s%s%s%s' % (
                 'shrub' if tag & TAG_SHRUB else '',
-                'name' if (tag & 0xfff) == TAG_NAME
+                'bname' if (tag & 0xfff) == TAG_BNAME
                     else 'reg' if (tag & 0xfff) == TAG_REG
                     else 'dir' if (tag & 0xfff) == TAG_DIR
                     else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE
                     else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK
+                    else 'mname' if (tag & 0xfff) == TAG_MNAME
                     else 'name 0x%02x' % (tag & 0xff),
                 ' w%d' % weight if weight else '',
                 ' %s' % size if size is not None else '')
diff --git a/scripts/dbgbtree.py b/scripts/dbgbtree.py
index c667114d..99660d30 100755
--- a/scripts/dbgbtree.py
+++ b/scripts/dbgbtree.py
@@ -31,10 +31,12 @@ TAG_NAMELIMIT   = 0x003a    #  0x003a  v--- ---- --11 1-1-
 TAG_GDELTA      = 0x0100    ## 0x01tt  v--- ---1 -ttt ttrr
 TAG_GRMDELTA    = 0x0100    #  0x0100  v--- ---1 ---- ----
 TAG_NAME        = 0x0200    ## 0x02tt  v--- --1- -ttt tttt
+TAG_BNAME       = 0x0200    #  0x0200  v--- --1- ---- ----
 TAG_REG         = 0x0201    #  0x0201  v--- --1- ---- ---1
 TAG_DIR         = 0x0202    #  0x0202  v--- --1- ---- --1-
 TAG_STICKYNOTE  = 0x0203    #  0x0203  v--- --1- ---- --11
 TAG_BOOKMARK    = 0x0204    #  0x0204  v--- --1- ---- -1--
+TAG_MNAME       = 0x0220    #  0x0220  v--- --1- --1- ----
 TAG_STRUCT      = 0x0300    ## 0x03tt  v--- --11 -ttt ttrr
 TAG_BRANCH      = 0x0300    #  0x030r  v--- --11 ---- --rr
 TAG_DATA        = 0x0304    #  0x0304  v--- --11 ---- -1--
@@ -222,11 +224,12 @@ def tagrepr(tag, weight=None, size=None, *,
     elif (tag & 0x6f00) == TAG_NAME:
         return '%s%s%s%s' % (
                 'shrub' if tag & TAG_SHRUB else '',
-                'name' if (tag & 0xfff) == TAG_NAME
+                'bname' if (tag & 0xfff) == TAG_BNAME
                     else 'reg' if (tag & 0xfff) == TAG_REG
                     else 'dir' if (tag & 0xfff) == TAG_DIR
                     else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE
                     else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK
+                    else 'mname' if (tag & 0xfff) == TAG_MNAME
                     else 'name 0x%02x' % (tag & 0xff),
                 ' w%d' % weight if weight else '',
                 ' %s' % size if size is not None else '')
diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py
index cd7feeab..a5a29030 100755
--- a/scripts/dbglfs.py
+++ b/scripts/dbglfs.py
@@ -32,10 +32,12 @@ TAG_NAMELIMIT   = 0x003a    #  0x003a  v--- ---- --11 1-1-
 TAG_GDELTA      = 0x0100    ## 0x01tt  v--- ---1 -ttt ttrr
 TAG_GRMDELTA    = 0x0100    #  0x0100  v--- ---1 ---- ----
 TAG_NAME        = 0x0200    ## 0x02tt  v--- --1- -ttt tttt
+TAG_BNAME       = 0x0200    #  0x0200  v--- --1- ---- ----
 TAG_REG         = 0x0201    #  0x0201  v--- --1- ---- ---1
 TAG_DIR         = 0x0202    #  0x0202  v--- --1- ---- --1-
 TAG_STICKYNOTE  = 0x0203    #  0x0203  v--- --1- ---- --11
 TAG_BOOKMARK    = 0x0204    #  0x0204  v--- --1- ---- -1--
+TAG_MNAME       = 0x0220    #  0x0220  v--- --1- --1- ----
 TAG_STRUCT      = 0x0300    ## 0x03tt  v--- --11 -ttt ttrr
 TAG_BRANCH      = 0x0300    #  0x030r  v--- --11 ---- --rr
 TAG_DATA        = 0x0304    #  0x0304  v--- --11 ---- -1--
@@ -271,11 +273,12 @@ def tagrepr(tag, weight=None, size=None, *,
     elif (tag & 0x6f00) == TAG_NAME:
         return '%s%s%s%s' % (
                 'shrub' if tag & TAG_SHRUB else '',
-                'name' if (tag & 0xfff) == TAG_NAME
+                'bname' if (tag & 0xfff) == TAG_BNAME
                     else 'reg' if (tag & 0xfff) == TAG_REG
                     else 'dir' if (tag & 0xfff) == TAG_DIR
                     else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE
                     else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK
+                    else 'mname' if (tag & 0xfff) == TAG_MNAME
                     else 'name 0x%02x' % (tag & 0xff),
                 ' w%d' % weight if weight else '',
                 ' %s' % size if size is not None else '')
diff --git a/scripts/dbgmtree.py b/scripts/dbgmtree.py
index 44576205..c7bcfce7 100755
--- a/scripts/dbgmtree.py
+++ b/scripts/dbgmtree.py
@@ -31,10 +31,12 @@ TAG_NAMELIMIT   = 0x003a    #  0x003a  v--- ---- --11 1-1-
 TAG_GDELTA      = 0x0100    ## 0x01tt  v--- ---1 -ttt ttrr
 TAG_GRMDELTA    = 0x0100    #  0x0100  v--- ---1 ---- ----
 TAG_NAME        = 0x0200    ## 0x02tt  v--- --1- -ttt tttt
+TAG_BNAME       = 0x0200    #  0x0200  v--- --1- ---- ----
 TAG_REG         = 0x0201    #  0x0201  v--- --1- ---- ---1
 TAG_DIR         = 0x0202    #  0x0202  v--- --1- ---- --1-
 TAG_STICKYNOTE  = 0x0203    #  0x0203  v--- --1- ---- --11
 TAG_BOOKMARK    = 0x0204    #  0x0204  v--- --1- ---- -1--
+TAG_MNAME       = 0x0220    #  0x0220  v--- --1- --1- ----
 TAG_STRUCT      = 0x0300    ## 0x03tt  v--- --11 -ttt ttrr
 TAG_BRANCH      = 0x0300    #  0x030r  v--- --11 ---- --rr
 TAG_DATA        = 0x0304    #  0x0304  v--- --11 ---- -1--
@@ -237,11 +239,12 @@ def tagrepr(tag, weight=None, size=None, *,
     elif (tag & 0x6f00) == TAG_NAME:
         return '%s%s%s%s' % (
                 'shrub' if tag & TAG_SHRUB else '',
-                'name' if (tag & 0xfff) == TAG_NAME
+                'bname' if (tag & 0xfff) == TAG_BNAME
                     else 'reg' if (tag & 0xfff) == TAG_REG
                     else 'dir' if (tag & 0xfff) == TAG_DIR
                     else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE
                     else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK
+                    else 'mname' if (tag & 0xfff) == TAG_MNAME
                     else 'name 0x%02x' % (tag & 0xff),
                 ' w%d' % weight if weight else '',
                 ' %s' % size if size is not None else '')
diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py
index a5a671ac..e7379c3b 100755
--- a/scripts/dbgrbyd.py
+++ b/scripts/dbgrbyd.py
@@ -41,10 +41,12 @@ TAG_NAMELIMIT   = 0x003a    #  0x003a  v--- ---- --11 1-1-
 TAG_GDELTA      = 0x0100    ## 0x01tt  v--- ---1 -ttt ttrr
 TAG_GRMDELTA    = 0x0100    #  0x0100  v--- ---1 ---- ----
 TAG_NAME        = 0x0200    ## 0x02tt  v--- --1- -ttt tttt
+TAG_BNAME       = 0x0200    #  0x0200  v--- --1- ---- ----
 TAG_REG         = 0x0201    #  0x0201  v--- --1- ---- ---1
 TAG_DIR         = 0x0202    #  0x0202  v--- --1- ---- --1-
 TAG_STICKYNOTE  = 0x0203    #  0x0203  v--- --1- ---- --11
 TAG_BOOKMARK    = 0x0204    #  0x0204  v--- --1- ---- -1--
+TAG_MNAME       = 0x0220    #  0x0220  v--- --1- --1- ----
 TAG_STRUCT      = 0x0300    ## 0x03tt  v--- --11 -ttt ttrr
 TAG_BRANCH      = 0x0300    #  0x030r  v--- --11 ---- --rr
 TAG_DATA        = 0x0304    #  0x0304  v--- --11 ---- -1--
@@ -225,11 +227,12 @@ def tagrepr(tag, weight=None, size=None, *,
     elif (tag & 0x6f00) == TAG_NAME:
         return '%s%s%s%s' % (
                 'shrub' if tag & TAG_SHRUB else '',
-                'name' if (tag & 0xfff) == TAG_NAME
+                'bname' if (tag & 0xfff) == TAG_BNAME
                     else 'reg' if (tag & 0xfff) == TAG_REG
                     else 'dir' if (tag & 0xfff) == TAG_DIR
                     else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE
                     else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK
+                    else 'mname' if (tag & 0xfff) == TAG_MNAME
                     else 'name 0x%02x' % (tag & 0xff),
                 ' w%d' % weight if weight else '',
                 ' %s' % size if size is not None else '')
diff --git a/scripts/dbgtag.py b/scripts/dbgtag.py
index 8ebeedaa..37e10207 100755
--- a/scripts/dbgtag.py
+++ b/scripts/dbgtag.py
@@ -24,10 +24,12 @@ TAG_NAMELIMIT   = 0x003a    #  0x003a  v--- ---- --11 1-1-
 TAG_GDELTA      = 0x0100    ## 0x01tt  v--- ---1 -ttt ttrr
 TAG_GRMDELTA    = 0x0100    #  0x0100  v--- ---1 ---- ----
 TAG_NAME        = 0x0200    ## 0x02tt  v--- --1- -ttt tttt
+TAG_BNAME       = 0x0200    #  0x0200  v--- --1- ---- ----
 TAG_REG         = 0x0201    #  0x0201  v--- --1- ---- ---1
 TAG_DIR         = 0x0202    #  0x0202  v--- --1- ---- --1-
 TAG_STICKYNOTE  = 0x0203    #  0x0203  v--- --1- ---- --11
 TAG_BOOKMARK    = 0x0204    #  0x0204  v--- --1- ---- -1--
+TAG_MNAME       = 0x0220    #  0x0220  v--- --1- --1- ----
 TAG_STRUCT      = 0x0300    ## 0x03tt  v--- --11 -ttt ttrr
 TAG_BRANCH      = 0x0300    #  0x030r  v--- --11 ---- --rr
 TAG_DATA        = 0x0304    #  0x0304  v--- --11 ---- -1--
@@ -129,11 +131,12 @@ def tagrepr(tag, weight=None, size=None, *,
     elif (tag & 0x6f00) == TAG_NAME:
         return '%s%s%s%s' % (
                 'shrub' if tag & TAG_SHRUB else '',
-                'name' if (tag & 0xfff) == TAG_NAME
+                'bname' if (tag & 0xfff) == TAG_BNAME
                     else 'reg' if (tag & 0xfff) == TAG_REG
                     else 'dir' if (tag & 0xfff) == TAG_DIR
                     else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE
                     else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK
+                    else 'mname' if (tag & 0xfff) == TAG_MNAME
                     else 'name 0x%02x' % (tag & 0xff),
                 ' w%d' % weight if weight else '',
                 ' %s' % size if size is not None else '')
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index 26c7f45b..ee20966f 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -3044,12 +3044,12 @@ code = '''
 
     // try to find tags
     lfsr_bid_t bid_;
-    lfsr_tag_t tag_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfs_size_t weight_;
-    lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_find_one]
@@ -3072,7 +3072,7 @@ code = '''
     lfsr_btree_init(&btree);
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 0, "aaa", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
@@ -3084,20 +3084,26 @@ code = '''
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
     assert(weight_ == 1);
@@ -3125,13 +3131,13 @@ code = '''
     lfsr_btree_init(&btree);
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 0, "aaa", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1),
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 0, "aab", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
@@ -3143,28 +3149,36 @@ code = '''
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aab", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aac", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
     assert(weight_ == 1);
@@ -3192,19 +3206,19 @@ code = '''
     lfsr_btree_init(&btree);
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 0, "aaa", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1),
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 1*DID, "aab", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1),
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 2*DID, "aac", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
@@ -3216,36 +3230,46 @@ code = '''
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "2", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
     assert(weight_ == 1);
@@ -3273,19 +3297,19 @@ code = '''
     lfsr_btree_init(&btree);
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 0, "aaa", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1),
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 2*DID, "aac", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1),
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 1*DID, "aab", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0;
     printf("btree: w%d 0x%x.%x\n",
@@ -3297,36 +3321,46 @@ code = '''
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
     assert(weight_ == 1);
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "2", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
-            &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
+    lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3,
+            &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
+    lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+            &tag_, &data_) => 0;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
     assert(weight_ == 1);
@@ -3358,7 +3392,7 @@ code = '''
     };
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 0, name, 3),
             LFSR_RATTR_BUF(
                 LFSR_TAG_DATA, 0,
@@ -3373,7 +3407,7 @@ code = '''
                     LFSR_TAG_DATA, 0,
                     &(uint8_t){'0'+((i-1) % 10)}, 1),
                 LFSR_RATTR_NAME(
-                    LFSR_TAG_NAME, +1,
+                    LFSR_TAG_REG, +1,
                     i*DID, name, 3),
                 LFSR_RATTR_BUF(
                     LFSR_TAG_DATA, 0,
@@ -3389,6 +3423,8 @@ code = '''
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
@@ -3398,8 +3434,10 @@ code = '''
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
 
-        lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
-                &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+        lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3,
+                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+                &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
         assert(weight_ == 1);
@@ -3429,7 +3467,7 @@ code = '''
     lfsr_btree_init(&btree);
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 0, "___", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0;
 
@@ -3469,7 +3507,7 @@ code = '''
                     LFSR_TAG_DATA, 0,
                     &(uint8_t){'0'+(i % 10)}, 1),
                 LFSR_RATTR_NAME(
-                    LFSR_TAG_NAME, +1,
+                    LFSR_TAG_REG, +1,
                     0, name, 3),
                 LFSR_RATTR_BUF(
                     LFSR_TAG_DATA, 0,
@@ -3503,12 +3541,16 @@ code = '''
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
-                &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+        lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
+                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+                &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
         assert(weight_ == 1);
@@ -3547,7 +3589,7 @@ code = '''
     };
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +W,
+                LFSR_TAG_REG, +W,
                 0, name, 3),
             LFSR_RATTR_BUF(
                 LFSR_TAG_DATA, 0,
@@ -3562,7 +3604,7 @@ code = '''
                     LFSR_TAG_DATA, 0,
                     &(uint8_t){'0'+((i-1) % 10)}, 1),
                 LFSR_RATTR_NAME(
-                    LFSR_TAG_NAME, +W,
+                    LFSR_TAG_REG, +W,
                     i*DID, name, 3),
                 LFSR_RATTR_BUF(
                     LFSR_TAG_DATA, 0,
@@ -3578,6 +3620,8 @@ code = '''
     // try to find tags
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
@@ -3587,8 +3631,10 @@ code = '''
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
 
-        lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
-                &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+        lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3,
+                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+                &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i*W+W-1);
         assert(weight_ == W);
@@ -3619,7 +3665,7 @@ code = '''
     lfsr_btree_init(&btree);
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +W,
+                LFSR_TAG_REG, +W,
                 0, "___", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0;
 
@@ -3674,7 +3720,7 @@ code = '''
                         LFSR_TAG_DATA, 0,
                         &(uint8_t){'0'+(i % 10)}, 1),
                     LFSR_RATTR_NAME(
-                        LFSR_TAG_NAME, +weight2,
+                        LFSR_TAG_REG, +weight2,
                         0, name, 3),
                     LFSR_RATTR_BUF(
                         LFSR_TAG_DATA, 0,
@@ -3727,6 +3773,8 @@ code = '''
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
@@ -3737,8 +3785,10 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
-                &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+        lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
+                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+                &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == weighted_bid+sim_weights[i]-1);
         assert(weight_ == sim_weights[i]);
@@ -3775,7 +3825,7 @@ code = '''
     lfsr_btree_init(&btree);
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +1,
+                LFSR_TAG_REG, +1,
                 0, "___", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0;
 
@@ -3816,28 +3866,28 @@ code = '''
             }
 
             // split btree
-            lfs_size_t split_bid;
-            lfsr_data_t split_data;
-            lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3,
-                    &split_bid, NULL, NULL, &split_data);
+            lfsr_bid_t split_bid;
+            lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree,
+                    0, name, 3,
+                    &split_bid, NULL, NULL, NULL, NULL, NULL);
             assert(cmp >= 0);
             assert(cmp != LFS_CMP_EQ);
             if (cmp > LFS_CMP_EQ) {
-                lfsr_btree_commit(&lfs, &btree,
-                        split_bid, LFSR_RATTRS(
-                            LFSR_RATTR_NAME(
-                                LFSR_TAG_NAME, +1,
-                                0, name, 3),
-                            LFSR_RATTR_BUF(
-                                LFSR_TAG_DATA, 0,
-                                &(uint8_t){'0'+(i % 10)}, 1))) => 0;
+                lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS(
+                        LFSR_RATTR_NAME(
+                            LFSR_TAG_REG, +1,
+                            0, name, 3),
+                        LFSR_RATTR_BUF(
+                            LFSR_TAG_DATA, 0,
+                            &(uint8_t){'0'+(i % 10)}, 1))) => 0;
             } else {
                 lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS(
-                        LFSR_RATTR_DATA(
-                            LFSR_TAG_DATA, 0,
-                            &split_data),
+                        // TODO can we avoid this noop? the problem is we need
+                        // some way to differentiate inserting before vs after
+                        // the requested bid
+                        LFSR_RATTR_NOOP(),
                         LFSR_RATTR_NAME(
-                            LFSR_TAG_NAME, +1,
+                            LFSR_TAG_REG, +1,
                             0, name, 3),
                         LFSR_RATTR_BUF(
                             LFSR_TAG_DATA, 0,
@@ -3892,12 +3942,16 @@ code = '''
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
-                &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+        lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
+                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+                &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
         assert(weight_ == 1);
@@ -3932,7 +3986,7 @@ code = '''
     lfsr_btree_init(&btree);
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
             LFSR_RATTR_NAME(
-                LFSR_TAG_NAME, +W,
+                LFSR_TAG_REG, +W,
                 0, "___", 3),
             LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0;
 
@@ -3984,29 +4038,30 @@ code = '''
             }
 
             // split btree
-            lfs_size_t split_bid;
-            lfs_size_t split_weight;
-            lfsr_data_t split_data;
-            lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3,
-                    &split_bid, NULL, &split_weight, &split_data);
+            lfsr_bid_t split_bid;
+            lfsr_bid_t split_weight;
+            lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree,
+                    0, name, 3,
+                    &split_bid, NULL, NULL, NULL, &split_weight, NULL);
             assert(cmp >= 0);
             assert(cmp != LFS_CMP_EQ);
             if (cmp > LFS_CMP_EQ) {
                 lfsr_btree_commit(&lfs, &btree,
                         split_bid-(split_weight-1), LFSR_RATTRS(
                             LFSR_RATTR_NAME(
-                                LFSR_TAG_NAME, +weight,
+                                LFSR_TAG_REG, +weight,
                                 0, name, 3),
                             LFSR_RATTR_BUF(
                                 LFSR_TAG_DATA, 0,
                                 &(uint8_t){'0'+(i % 10)}, 1))) => 0;
             } else {
                 lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS(
-                        LFSR_RATTR_DATA(
-                            LFSR_TAG_DATA, 0,
-                            &split_data),
+                        // TODO can we avoid this noop? the problem is we need
+                        // some way to differentiate inserting before vs after
+                        // the requested bid
+                        LFSR_RATTR_NOOP(),
                         LFSR_RATTR_NAME(
-                            LFSR_TAG_NAME, +weight,
+                            LFSR_TAG_REG, +weight,
                             0, name, 3),
                         LFSR_RATTR_BUF(
                             LFSR_TAG_DATA, 0,
@@ -4087,6 +4142,8 @@ code = '''
 
     uint8_t buffer[4];
     lfsr_bid_t bid_;
+    lfsr_rbyd_t rbyd_;
+    lfsr_srid_t rid_;
     lfsr_tag_t tag_;
     lfs_size_t weight_;
     lfsr_data_t data_;
@@ -4097,8 +4154,10 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
-                &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
+        lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
+                &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
+        lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
+                &tag_, &data_) => 0;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == weighted_bid+sim_weights[i]-1);
         assert(weight_ == sim_weights[i]);
diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml
index 06ce8ca2..ecc1f1bf 100644
--- a/tests/test_rbyd.toml
+++ b/tests/test_rbyd.toml
@@ -4480,8 +4480,7 @@ 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, NULL, &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);
         }
@@ -6219,7 +6218,8 @@ 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, NULL, &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,8 @@ code = '''
                         assert(rid_ == k);
                         assert(lfsr_data_size(data_) == 2);
 
-                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &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 +6264,8 @@ 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, NULL, &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 +6278,8 @@ code = '''
                         assert(rid_ == k);
                         assert(lfsr_data_size(data_) == 3);
 
-                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &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 +6287,8 @@ code = '''
                         assert(rid_ == k);
                         assert(lfsr_data_size(data_) == 2);
 
-                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &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);
                     }
@@ -6627,14 +6631,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,
-                    -1, LFSR_TAG_ATTR(j+1), NULL, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, -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, NULL, &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);
         }
@@ -6779,8 +6782,8 @@ 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,
-                    -1, LFSR_TAG_ATTR(j+1), NULL, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, -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);
         }
@@ -10614,7 +10617,8 @@ 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, NULL, &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);
@@ -10637,11 +10641,13 @@ code = '''
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &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, NULL, &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 +10789,8 @@ 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, NULL, &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);
@@ -10792,8 +10799,8 @@ code = '''
                 }
 
                 for (unsigned u = 0; u < M; u++) {
-                    lfsr_rbyd_lookup(&lfs, &rbyd,
-                            k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, 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);
@@ -10825,24 +10832,26 @@ code = '''
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &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), NULL, &data) => 0;
+                        lfsr_rbyd_lookup(&lfs, &rbyd, 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, NULL, &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), NULL, &data) => 0;
+                        lfsr_rbyd_lookup(&lfs, &rbyd, 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);
                     }
@@ -11573,8 +11582,7 @@ code = '''
         // check that all tags are now removed
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 0);
-        lfsr_rbyd_lookup(&lfs, &rbyd,
-                LFSR_TAG_DATA, 0,
+        lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_DATA, 0,
                 NULL, &data) => LFS_ERR_NOENT;
 
         // try resuming from all tags being removed
@@ -11586,12 +11594,10 @@ code = '''
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 1);
-        lfsr_rbyd_lookup(&lfs, &rbyd,
-                0, LFSR_TAG_DATA, NULL, &data) => 0;
+        lfsr_rbyd_lookup(&lfs, &rbyd, 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,
+        lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
                 NULL, &data) => LFS_ERR_NOENT;
 
         // keep track of the worst size
@@ -11729,8 +11735,7 @@ code = '''
         // check that all tags are now removed
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 0);
-        lfsr_rbyd_lookup(&lfs, &rbyd,
-                0, LFSR_TAG_DATA,
+        lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
                 NULL, &data) => LFS_ERR_NOENT;
 
         // try resuming from all tags being removed
@@ -11748,21 +11753,18 @@ code = '''
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 1);
-        lfsr_rbyd_lookup(&lfs, &rbyd,
-                0, LFSR_TAG_DATA, NULL, &data) => 0;
+        lfsr_rbyd_lookup(&lfs, &rbyd, 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), NULL, &data) => 0;
+            lfsr_rbyd_lookup(&lfs, &rbyd, 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,
+        lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
                 NULL, &data) => LFS_ERR_NOENT;
-        lfsr_rbyd_lookup(&lfs, &rbyd,
-                1, LFSR_TAG_ATTR(1),
+        lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1),
                 NULL, &data) => LFS_ERR_NOENT;
 
         // keep track of the worst size
@@ -12349,7 +12351,8 @@ code = '''
             assert(weight_ == W);
             assert(lfsr_data_size(data_) == 4);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, NULL, &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);
         }
@@ -13559,7 +13562,8 @@ code = '''
             assert(weight_ == 0);
             assert(lfsr_data_size(data_) == 2);
 
-            lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, NULL, &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);
         }
@@ -16267,10 +16271,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_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k,
+                            LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => LFS_ERR_NOENT;
                 } else {
-                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | 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);
@@ -16638,10 +16644,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_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k,
+                            LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
                             &tag_, &data_) => LFS_ERR_NOENT;
                 } else {
-                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | 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);