diff --git a/lfs.c b/lfs.c
index 0142ec67..d0921657 100644
--- a/lfs.c
+++ b/lfs.c
@@ -1357,73 +1357,73 @@ static inline int lfsr_data_readlleb128(lfs_t *lfs, lfsr_data_t *data,
     return 0;
 }
 
-static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs, const lfsr_data_t *data,
-        const void *buffer, lfs_size_t size) {
-    // limit our size to data range
-    lfs_size_t d = lfs_min32(size, lfsr_data_size(data));
+static lfs_scmp_t lfsr_data_cmp_(lfs_t *lfs,
+        const lfsr_data_t *a,
+        const lfsr_data_t *b,
+        lfs_size_t size) {
+    // on-disk cmp buffer?
+    if (lfsr_data_ondisk(a) && lfsr_data_isbuf(b)) {
+        return lfsr_bd_cmp(lfs, a->u.disk.block, a->u.disk.off, 0,
+                b->u.buf.buffer, size);
 
-    // on-disk?
-    if (lfsr_data_ondisk(data)) {
-        int cmp = lfsr_bd_cmp(lfs, data->u.disk.block, data->u.disk.off, 0,
-                buffer, d);
+    // on-disk cmp inlined?
+    } else if (lfsr_data_ondisk(a) && lfsr_data_isimm(b)) {
+        return lfsr_bd_cmp(lfs, a->u.disk.block, a->u.disk.off, 0,
+                b->u.imm.buf, size);
+
+    // not supported
+    } else {
+        LFS_UNREACHABLE();
+    }
+}
+
+static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs,
+        const lfsr_data_t *a,
+        const lfsr_data_t *b) {
+    // simple data?
+    if (!lfsr_data_iscat(b)) {
+        // compare common prefix
+        lfs_scmp_t cmp = lfsr_data_cmp_(lfs, a, b,
+                lfs_min32(
+                    lfsr_data_size(a),
+                    lfsr_data_size(b)));
         if (cmp != LFS_CMP_EQ) {
             return cmp;
         }
 
-    // buffer?
-    } else if (lfsr_data_isbuf(data)) {
-        int cmp = memcmp(data->u.buf.buffer, buffer, d);
-        if (cmp < 0) {
-            return LFS_CMP_LT;
-        } else if (cmp > 0) {
-            return LFS_CMP_GT;
-        }
-
-    // inlined?
-    } else if (lfsr_data_isimm(data)) {
-        int cmp = memcmp(data->u.imm.buf, buffer, d);
-        if (cmp < 0) {
-            return LFS_CMP_LT;
-        } else if (cmp > 0) {
-            return LFS_CMP_GT;
-        }
-
-    // concatenated? not supported
+    // concatenated data? handle specially to avoid recursion
     } else {
-        LFS_UNREACHABLE();
+        // compare common prefix
+        lfs_size_t size = lfs_min32(
+                lfsr_data_size(a),
+                lfsr_data_size(b));
+        lfsr_data_t a_ = *a;
+        const lfsr_data_t *b_ = b->u.cat.datas;
+        while (size > 0) {
+            lfs_size_t d = lfs_min32(
+                    size,
+                    lfsr_data_size(b_));
+            lfs_scmp_t cmp = lfsr_data_cmp_(lfs, &a_, b_, d);
+            if (cmp != LFS_CMP_EQ) {
+                return cmp;
+            }
+
+            a_ = lfsr_data_slice(a_, d, -1);
+            size -= d;
+            b_ += 1;
+        }
     }
 
     // if data is equal, check for size mismatch
-    if (lfsr_data_size(data) < size) {
+    if (lfsr_data_size(a) < lfsr_data_size(b)) {
         return LFS_CMP_LT;
-    } else if (lfsr_data_size(data) > size) {
+    } else if (lfsr_data_size(a) > lfsr_data_size(b)) {
         return LFS_CMP_GT;
     } else {
         return LFS_CMP_EQ;
     }
 }
 
-static lfs_scmp_t lfsr_data_namecmp(lfs_t *lfs, const lfsr_data_t *data,
-        lfsr_did_t did, const char *name, lfs_size_t name_size) {
-    // first compare the did
-    lfsr_data_t data_ = *data;
-    lfsr_did_t did_;
-    int err = lfsr_data_readleb128(lfs, &data_, &did_);
-    if (err) {
-        LFS_ASSERT(err < 0);
-        return err;
-    }
-
-    if (did_ < did) {
-        return LFS_CMP_LT;
-    } else if (did_ > did) {
-        return LFS_CMP_GT;
-    }
-
-    // then compare the actual name
-    return lfsr_data_cmp(lfs, &data_, name, name_size);
-}
-
 static int lfsr_bd_progdata_(lfs_t *lfs,
         lfs_block_t block, lfs_size_t off, lfsr_data_t data,
         uint32_t *cksum_, uint32_t *flcksum_) {
@@ -1468,11 +1468,8 @@ static int lfsr_bd_progdata(lfs_t *lfs,
         uint32_t *cksum_, uint32_t *flcksum_) {
     // simple data?
     if (!lfsr_data_iscat(&data)) {
-        int err = lfsr_bd_progdata_(lfs, block, off, data,
+        return lfsr_bd_progdata_(lfs, block, off, data,
                 cksum_, flcksum_);
-        if (err) {
-            return err;
-        }
 
     // concatenated data? handle specially to avoid recursion
     } else {
@@ -1489,9 +1486,9 @@ static int lfsr_bd_progdata(lfs_t *lfs,
             size -= lfsr_data_size(datas);
             datas += 1;
         }
-    }
 
-    return 0;
+        return 0;
+    }
 }
 
 
@@ -3741,7 +3738,7 @@ static int lfsr_rbyd_appendshrub(lfs_t *lfs, lfsr_rbyd_t *rbyd,
 // binary search an rbyd for a name, leaving the rid_/tag_/weight_/data_
 // with the best matching name if not found
 static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
-        lfsr_did_t did, const char *name, lfs_size_t name_size,
+        const lfsr_data_t *name,
         lfsr_srid_t *rid_,
         lfsr_tag_t *tag_, lfsr_rid_t *weight_, lfsr_data_t *data_) {
     // empty rbyd? leave it up to upper layers to handle this
@@ -3775,7 +3772,7 @@ static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
 
         // compare names
         } else {
-            cmp = lfsr_data_namecmp(lfs, &data__, did, name, name_size);
+            cmp = lfsr_data_cmp(lfs, &data__, name);
             if (cmp < 0) {
                 return cmp;
             }
@@ -4701,7 +4698,7 @@ static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree, lfsr_bid_t bid,
 
 // lookup in a btree by name
 static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree,
-        lfsr_did_t did, const char *name, lfs_size_t name_size,
+        const lfsr_data_t *name,
         lfsr_bid_t *bid_,
         lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) {
     // an empty tree?
@@ -4716,8 +4713,7 @@ static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree,
         // lookup our name in the rbyd via binary search
         lfsr_srid_t rid__;
         lfsr_rid_t weight__;
-        lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &branch,
-                did, name, name_size,
+        lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &branch, name,
                 &rid__, NULL, &weight__, NULL);
         if (cmp < 0) {
             LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -6926,7 +6922,9 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
     lfsr_srid_t rid;
     lfsr_tag_t tag;
     lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->rbyd,
-            did, name, name_size,
+            &LFSR_DATA_CAT(
+                LFSR_DATA_LEB128(did),
+                LFSR_DATA_BUF(name, name_size)),
             &rid, &tag, NULL, data_);
     if (cmp < 0) {
         LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -6985,7 +6983,9 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, const lfsr_mtree_t *mtree,
         lfsr_bid_t weight;
         lfsr_data_t data;
         lfs_scmp_t cmp = lfsr_btree_namelookup(lfs, &mtree->u.btree,
-                did, name, name_size,
+                &LFSR_DATA_CAT(
+                    LFSR_DATA_LEB128(did),
+                    LFSR_DATA_BUF(name, name_size)),
                 &bid, &tag, &weight, &data);
         if (cmp < 0) {
             LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -7746,7 +7746,8 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
         return err;
     }
 
-    lfs_scmp_t cmp = lfsr_data_cmp(lfs, &data, "littlefs", 8);
+    lfs_scmp_t cmp = lfsr_data_cmp(lfs, &data,
+            &LFSR_DATA_BUF("littlefs", 8));
     if (cmp < 0) {
         return cmp;
     }
diff --git a/scripts/dbgbmap.py b/scripts/dbgbmap.py
index c9e41658..83f6bbd5 100755
--- a/scripts/dbgbmap.py
+++ b/scripts/dbgbmap.py
@@ -1175,134 +1175,6 @@ class Rbyd:
                 else:
                     return True, -1, 0, None
 
-    # lookup by name
-    def namelookup(self, did, name):
-        # binary search
-        best = (False, -1, 0, 0)
-        lower = 0
-        upper = self.weight
-        while lower < upper:
-            done, rid, tag, w, j, d, data, _ = self.lookup(
-                lower + (upper-1-lower)//2, TAG_NAME)
-            if done:
-                break
-
-            # treat vestigial names as a catch-all
-            if ((tag == TAG_NAME and rid-(w-1) == 0)
-                    or (tag & 0xff00) != TAG_NAME):
-                did_ = 0
-                name_ = b''
-            else:
-                did_, d = fromleb128(data)
-                name_ = data[d:]
-
-            # bisect search space
-            if (did_, name_) > (did, name):
-                upper = rid-(w-1)
-            elif (did_, name_) < (did, name):
-                lower = rid + 1
-
-                # keep track of best match
-                best = (False, rid, tag, w)
-            else:
-                # found a match
-                return True, rid, tag, w
-
-        return best
-
-    # lookup by name with this rbyd as the btree root
-    def btree_namelookup(self, f, block_size, did, name):
-        rbyd = self
-        bid = 0
-
-        while True:
-            found, rid, tag, w = rbyd.namelookup(did, name)
-            done, rid_, tag_, w_, j, d, data, _ = rbyd.lookup(rid, TAG_STRUCT)
-
-            # found another branch
-            if tag_ & 0xfff == TAG_BRANCH:
-                # update our bid
-                bid += rid - (w-1)
-
-                block, trunk, cksum = frombranch(data)
-                rbyd = Rbyd.fetch(f, block_size, block, trunk)
-
-            # found best match
-            else:
-                return bid + rid, tag_, w, data
-
-    # lookup by name with this rbyd as the mroot
-    def mtree_namelookup(self, f, block_size, did, name):
-        # have mtree?
-        done, rid, tag, w, j, d, data, _ = self.lookup(-1, TAG_MTREE)
-        if not done and rid == -1 and tag == TAG_MTREE:
-            w, block, trunk, cksum = frombtree(data)
-            mtree = Rbyd.fetch(f, block_size, block, trunk)
-            # corrupted?
-            if not mtree:
-                return False, -1, 0, None, -1, 0, 0
-
-            # lookup our name in the mtree
-            mbid, tag_, mw, data = mtree.btree_namelookup(
-                f, block_size, did, name)
-            if tag_ != TAG_MDIR:
-                return False, -1, 0, None, -1, 0, 0
-
-            # fetch the mdir
-            blocks = frommdir(data)
-            mdir = Rbyd.fetch(f, block_size, blocks)
-
-        else:
-            # have mdir?
-            done, rid, tag, w, j, _, data, _ = self.lookup(-1, TAG_MDIR)
-            if not done and rid == -1 and tag == TAG_MDIR:
-                blocks = frommdir(data)
-                mbid = 0
-                mw = 0
-                mdir = Rbyd.fetch(f, block_size, blocks)
-
-            else:
-                # I guess we're inlined?
-                mbid = -1
-                mw = 0
-                mdir = self
-
-        # lookup name in our mdir
-        found, rid, tag, w = mdir.namelookup(did, name)
-        return found, mbid, mw, mdir, rid, tag, w
-
-    # iterate through a directory assuming this is the mtree root
-    def mtree_dir(self, f, block_size, did):
-        # lookup the bookmark
-        found, mbid, mw, mdir, rid, tag, w = self.mtree_namelookup(
-            f, block_size, did, b'')
-        # iterate through all files until the next bookmark
-        while found:
-            # lookup each rid
-            done, rid, tag, w, j, d, data, _ = mdir.lookup(rid, TAG_NAME)
-            if done:
-                break
-
-            # parse out each name
-            did_, d_ = fromleb128(data)
-            name_ = data[d_:]
-
-            # end if we see another did
-            if did_ != did:
-                break
-
-            # yield what we've found
-            yield name_, mbid, mw, mdir, rid, tag, w
-
-            rid += w
-            if rid >= mdir.weight:
-                rid -= mdir.weight
-                mbid += 1
-
-                done, mbid, mw, mdir = self.mtree_lookup(f, block_size, mbid)
-                if done:
-                    break
-
 
 def main(disk, mroots=None, *,
         block_size=None,
diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py
index 31e16da8..5645a49b 100755
--- a/scripts/dbglfs.py
+++ b/scripts/dbglfs.py
@@ -131,6 +131,18 @@ def fromleb128(data):
             return word, i+1
     return word, len(data)
 
+def toleb128(word):
+    data = []
+    word &= 0xffffffff
+    while True:
+        b, word = word & 0x7f, word >> 7
+        if word:
+            data.append(b | 0x80)
+        else:
+            data.append(b | 0x00)
+            break
+    return bytes(data)
+
 def fromtag(data):
     data = data.ljust(4, b'\0')
     tag = (data[0] << 8) | data[1]
@@ -868,7 +880,7 @@ class Rbyd:
                     return True, -1, 0, None
 
     # lookup by name
-    def namelookup(self, did, name):
+    def namelookup(self, name):
         # binary search
         best = (False, -1, 0, 0)
         lower = 0
@@ -882,16 +894,14 @@ class Rbyd:
             # treat vestigial names as a catch-all
             if ((tag == TAG_NAME and rid-(w-1) == 0)
                     or (tag & 0xff00) != TAG_NAME):
-                did_ = 0
                 name_ = b''
             else:
-                did_, d = fromleb128(data)
-                name_ = data[d:]
+                name_ = data
 
             # bisect search space
-            if (did_, name_) > (did, name):
+            if name_ > name:
                 upper = rid-(w-1)
-            elif (did_, name_) < (did, name):
+            elif name_ < name:
                 lower = rid + 1
 
                 # keep track of best match
@@ -903,12 +913,12 @@ class Rbyd:
         return best
 
     # lookup by name with this rbyd as the btree root
-    def btree_namelookup(self, f, block_size, did, name):
+    def btree_namelookup(self, f, block_size, name):
         rbyd = self
         bid = 0
 
         while True:
-            found, rid, tag, w = rbyd.namelookup(did, name)
+            found, rid, tag, w = rbyd.namelookup(name)
             done, rid_, tag_, w_, j, d, data, _ = rbyd.lookup(rid, TAG_STRUCT)
 
             # found another branch
@@ -925,6 +935,9 @@ class Rbyd:
 
     # lookup by name with this rbyd as the mroot
     def mtree_namelookup(self, f, block_size, did, name):
+        # concatenate did + name
+        name = toleb128(did) + name
+
         # have mtree?
         done, rid, tag, w, j, d, data, _ = self.lookup(-1, TAG_MTREE)
         if not done and rid == -1 and tag == TAG_MTREE:
@@ -936,7 +949,7 @@ class Rbyd:
 
             # lookup our name in the mtree
             mbid, tag_, mw, data = mtree.btree_namelookup(
-                f, block_size, did, name)
+                f, block_size, name)
             if tag_ != TAG_MDIR:
                 return False, -1, 0, None, -1, 0, 0
 
@@ -960,7 +973,7 @@ class Rbyd:
                 mdir = self
 
         # lookup name in our mdir
-        found, rid, tag, w = mdir.namelookup(did, name)
+        found, rid, tag, w = mdir.namelookup(name)
         return found, mbid, mw, mdir, rid, tag, w
 
     # iterate through a directory assuming this is the mtree root
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index a3cf8c21..784ea71a 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -3226,13 +3226,11 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_find_one]
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3249,9 +3247,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -3266,7 +3262,7 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3274,7 +3270,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aab", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3284,8 +3280,6 @@ code = '''
 '''
 
 [cases.test_btree_find_two]
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3302,15 +3296,11 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -3325,7 +3315,7 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3333,7 +3323,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aab", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3341,7 +3331,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aac", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3352,8 +3342,6 @@ code = '''
 
 [cases.test_btree_find_three]
 in = 'lfs.c'
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 code = '''
     lfs_t lfs;
     lfs_init(&lfs, CFG) => 0;
@@ -3369,27 +3357,15 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(0),
-                    LFSR_DATA_BUF("aaa", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(1*DID),
-                    LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(2*DID),
-                    LFSR_DATA_BUF("aac", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aac", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -3404,7 +3380,7 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3412,7 +3388,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aab", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3420,7 +3396,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aac", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3428,7 +3404,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "2", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aad", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3438,8 +3414,6 @@ code = '''
 '''
 
 [cases.test_btree_find_three_backwards]
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3456,27 +3430,15 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(0),
-                    LFSR_DATA_BUF("aaa", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(2*DID),
-                    LFSR_DATA_BUF("aac", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aac", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(1*DID),
-                    LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -3491,7 +3453,7 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3499,7 +3461,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aab", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3507,7 +3469,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aac", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3515,7 +3477,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "2", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aad", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3526,8 +3488,6 @@ code = '''
 
 [cases.test_btree_find]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3547,9 +3507,7 @@ code = '''
         'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26)
     };
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)),
             LFSR_ATTR(
                 LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
@@ -3562,10 +3520,7 @@ code = '''
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
-                LFSR_ATTR(
-                    LFSR_TAG_NAME, +1, LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(i*DID),
-                        LFSR_DATA_BUF(name, 3))),
+                LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
@@ -3594,7 +3549,7 @@ code = '''
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
 
-        lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(name, 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -3623,9 +3578,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("___", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
@@ -3665,9 +3618,7 @@ code = '''
                     LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
                 LFSR_ATTR(
                     LFSR_TAG_NAME, +1,
-                    LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(0),
-                        LFSR_DATA_BUF(name, 3))),
+                    LFSR_DATA_BUF(name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -3709,7 +3660,7 @@ code = '''
     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,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(sim_names[i], 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -3727,8 +3678,6 @@ code = '''
 [cases.test_btree_find_sparse]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.W = 5
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3748,9 +3697,7 @@ code = '''
         'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26)
     };
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF(name, 3)),
             LFSR_ATTR(
                 LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
@@ -3763,11 +3710,7 @@ code = '''
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
-                LFSR_ATTR(
-                    LFSR_TAG_NAME, +W,
-                    LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(i*DID),
-                        LFSR_DATA_BUF(name, 3))),
+                LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF(name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
@@ -3796,7 +3739,7 @@ code = '''
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
 
-        lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(name, 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i*W+W-1);
@@ -3826,9 +3769,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF("___", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
@@ -3884,9 +3825,7 @@ code = '''
                         LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
                     LFSR_ATTR(
                         LFSR_TAG_NAME, +weight2,
-                        LFSR_DATA_CAT(
-                            LFSR_DATA_LEB128(0),
-                            LFSR_DATA_BUF(name, 3))),
+                        LFSR_DATA_BUF(name, 3)),
                     LFSR_ATTR(
                         LFSR_TAG_DATA, 0,
                         LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -3953,7 +3892,7 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(sim_names[i], 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == weighted_bid+sim_weights[i]-1);
@@ -3989,9 +3928,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("___", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
@@ -4033,7 +3970,8 @@ 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,
+            lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree,
+                    &LFSR_DATA_BUF(name, 3),
                     &split_bid, NULL, NULL, &split_data);
             assert(cmp >= 0);
             assert(cmp != LFS_CMP_EQ);
@@ -4042,9 +3980,7 @@ code = '''
                         split_bid, LFSR_ATTRS(
                             LFSR_ATTR(
                                 LFSR_TAG_NAME, +1,
-                                LFSR_DATA_CAT(
-                                    LFSR_DATA_LEB128(0),
-                                    LFSR_DATA_BUF(name, 3))),
+                                LFSR_DATA_BUF(name, 3)),
                             LFSR_ATTR(
                                 LFSR_TAG_DATA, 0,
                                 LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4056,11 +3992,7 @@ code = '''
             } else {
                 int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
                         LFSR_ATTR(LFSR_TAG_DATA, 0, split_data),
-                        LFSR_ATTR(
-                            LFSR_TAG_NAME, +1,
-                            LFSR_DATA_CAT(
-                                LFSR_DATA_LEB128(0),
-                                LFSR_DATA_BUF(name, 3))),
+                        LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)),
                         LFSR_ATTR(
                             LFSR_TAG_DATA, 0,
                             LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4133,7 +4065,7 @@ code = '''
     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,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(sim_names[i], 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -4169,7 +4101,7 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
+                LFSR_DATA_BUF("___", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
@@ -4223,7 +4155,8 @@ code = '''
             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,
+            lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree,
+                    &LFSR_DATA_BUF(name, 3),
                     &split_bid, NULL, &split_weight, &split_data);
             assert(cmp >= 0);
             assert(cmp != LFS_CMP_EQ);
@@ -4232,9 +4165,7 @@ code = '''
                         split_bid-(split_weight-1), LFSR_ATTRS(
                             LFSR_ATTR(
                                 LFSR_TAG_NAME, +weight,
-                                LFSR_DATA_CAT(
-                                    LFSR_DATA_LEB128(0),
-                                    LFSR_DATA_BUF(name, 3))),
+                                LFSR_DATA_BUF(name, 3)),
                             LFSR_ATTR(
                                 LFSR_TAG_DATA, 0,
                                 LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4248,9 +4179,7 @@ code = '''
                         LFSR_ATTR(LFSR_TAG_DATA, 0, split_data),
                         LFSR_ATTR(
                             LFSR_TAG_NAME, +weight,
-                            LFSR_DATA_CAT(
-                                LFSR_DATA_LEB128(0),
-                                LFSR_DATA_BUF(name, 3))),
+                            LFSR_DATA_BUF(name, 3)),
                         LFSR_ATTR(
                             LFSR_TAG_DATA, 0,
                             LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4357,7 +4286,7 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(sim_names[i], 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == weighted_bid+sim_weights[i]-1);