diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index fc3e679b..ea5e4ce4 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -5,104 +5,6 @@ after = 'test_rbyd'
 # of the disk for these tests
 defines.LOOKAHEAD_SIZE = 'lfs_alignup(BLOCK_COUNT / 8, 8)'
 
-# TODO we should eventually replace these with
-# lfsr_btree_commit/lfsr_btree_lookup
-# helper functions
-in = 'lfs.c'
-code = '''
-    static int lfsr_btree_get(lfs_t *lfs,
-            const lfsr_btree_t *btree, lfs_size_t bid,
-            lfsr_tag_t *tag_, lfs_size_t *weight_,
-            void *buffer, lfs_size_t size) {
-        lfsr_data_t data;
-        int err = lfsr_btree_lookup(lfs, btree, bid,
-                tag_, weight_, &data);
-        if (err) {
-            return err;
-        }
-
-        return lfsr_data_read(lfs, &data, buffer, size);
-    }
-
-    static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree,
-            lfs_size_t bid, lfsr_tag_t tag, lfs_size_t weight,
-            lfsr_data_t data) {
-        LFS_ASSERT(bid <= btree->weight);
-        return lfsr_btree_commit(lfs, btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(TAG(tag), +weight, DATA(data))));
-    }
-
-    static int lfsr_btree_set(lfs_t *lfs, lfsr_btree_t *btree,
-            lfs_size_t bid, lfsr_tag_t tag, lfs_size_t weight,
-            lfsr_data_t data) {
-        LFS_ASSERT(bid < btree->weight);
-        LFS_ASSERT(btree->weight > 0);
-
-        // lookup weight to compute deltas
-        lfs_size_t weight_;
-        int err = lfsr_btree_lookupnext(lfs, btree, bid,
-                NULL, NULL, &weight_, NULL);
-        if (err) {
-            return err;
-        }
-
-        // note we need a second tag here in case our entry has a
-        // name attributes, the name attribute holds the weight not
-        // the struct tag
-        return lfsr_btree_commit(lfs, btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(SUBMASK(TAG(tag)), 0, DATA(data)),
-                LFSR_ATTR(GROW, weight - weight_, NULL())));
-    }
-
-    static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) {
-        LFS_ASSERT(bid < btree->weight);
-        LFS_ASSERT(btree->weight > 0);
-
-        // lookup weight to compute deltas
-        lfs_size_t weight_;
-        int err = lfsr_btree_lookupnext(lfs, btree, bid,
-                NULL, NULL, &weight_, NULL);
-        if (err) {
-            return err;
-        }
-
-        return lfsr_btree_commit(lfs, btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(RM, -weight_, NULL())));
-    }
-
-    static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree,
-            lfs_size_t bid, lfsr_data_t name,
-            lfsr_tag_t tag1, lfs_size_t weight1, lfsr_data_t data1,
-            lfsr_tag_t tag2, lfs_size_t weight2, lfsr_data_t data2) {
-        LFS_ASSERT(bid < btree->weight);
-        LFS_ASSERT(btree->weight > 0);
-
-        // lookup weight to compute deltas
-        lfs_size_t weight_;
-        int err = lfsr_btree_lookupnext(lfs, btree, bid,
-                NULL, NULL, &weight_, NULL);
-        if (err) {
-            return err;
-        }
-
-        lfsr_attr_t attrs[4];
-        lfs_size_t attr_count = 0;
-
-        attrs[attr_count++] = LFSR_ATTR(GROW, +weight1-weight_, NULL());
-        attrs[attr_count++] = LFSR_ATTR(TAG(tag1), 0, DATA(data1));
-        if (lfsr_data_size(&name) > 0) {
-            attrs[attr_count++] = LFSR_ATTR(NAME, +weight2, DATA(name));
-            attrs[attr_count++] = LFSR_ATTR(TAG(tag2), 0, DATA(data2));
-        } else {
-            attrs[attr_count++] = LFSR_ATTR(TAG(tag2), +weight2, DATA(data2));
-        }
-
-        LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t));
-        return lfsr_btree_commit(lfs, btree, bid, attrs, attr_count);
-    }
-'''
-
-
 # test an empty tree
 [cases.test_btree_zero]
 in = 'lfs.c'
@@ -127,12 +29,12 @@ code = '''
     assert(btree.weight == 0);
 
     // try looking up tags
-    uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 # test an inlined tree
@@ -152,8 +54,8 @@ code = '''
     // create a single-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -164,15 +66,17 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 # test a single-rbyd tree
@@ -192,10 +96,10 @@ code = '''
     // create a two-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -206,21 +110,24 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "b", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_two_backwards]
@@ -239,10 +146,10 @@ code = '''
     // create a two-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -253,21 +160,24 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "b", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 # still a single-rbyd tree, just making sure it works
@@ -287,12 +197,12 @@ code = '''
     // create a two-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("c", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("c", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -303,27 +213,31 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "b", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "c", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 3,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 3,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_three_backwards]
@@ -342,12 +256,12 @@ code = '''
     // create a two-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("c", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("c", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -358,27 +272,31 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "b", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "c", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 3,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 3,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 # try larger trees, when exactly a tree splits depends on the disk geometry, so
@@ -402,8 +320,8 @@ code = '''
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfs_size_t n = 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -421,18 +339,20 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < n; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, n,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, n,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_push_backwards]
@@ -454,8 +374,8 @@ code = '''
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfs_size_t n = 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -473,18 +393,20 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < n; i++) {
-        lfsr_btree_get(&lfs, &btree, n-1-i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, n-1-i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &(uint8_t){'a'+((N-1-i) % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, n,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, n,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_push_fuzz]
@@ -520,8 +442,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1);
 
         // add to btree
-        int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -554,17 +476,19 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, sim_size,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, sim_size,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // clean up sim
     free(sim);
@@ -591,8 +515,8 @@ code = '''
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfs_size_t n = 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_DATA, W,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -610,22 +534,23 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < n; i++) {
-        lfsr_btree_get(&lfs, &btree, i*W+W-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i*W+W-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == W);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, n*W,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, n*W,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     lfs_size_t bid_ = -1;
-    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < n; i++) {
         lfsr_btree_lookupnext(&lfs, &btree, bid_+1,
                 &bid_, &tag_, &weight_, &data_) => 0;
@@ -684,9 +609,8 @@ code = '''
         }
 
         // add to btree
-        int err = lfsr_btree_push(&lfs, &btree,
-                weighted_bid, LFSR_TAG_DATA, weight,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +weight, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -734,6 +658,7 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -741,20 +666,20 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == sim_weights[i]);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, total_weight,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, total_weight,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     lfs_size_t bid_ = -1;
-    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -798,11 +723,11 @@ code = '''
     // create a single-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
     // update the tree
-    lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("A", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -813,15 +738,17 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "A", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update_two]
@@ -840,15 +767,15 @@ code = '''
     // create a two-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
     // update the tree
-    lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("A", 1)) => 0;
-    lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("B", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF("A", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF("B", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -859,21 +786,24 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "A", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "B", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update_three]
@@ -892,19 +822,19 @@ code = '''
     // create a two-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("c", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("c", 1)))) => 0;
     // update the tree
-    lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("A", 1)) => 0;
-    lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("B", 1)) => 0;
-    lfsr_btree_set(&lfs, &btree, 2, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("C", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF("A", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF("B", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF("C", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -915,27 +845,31 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "A", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "B", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "C", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 3,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 3,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update]
@@ -956,8 +890,8 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -970,8 +904,8 @@ code = '''
     }
     // update the tree
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_set(&lfs, &btree, i, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
+                LFSR_ATTR(SUBMASK(DATA), 0, BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -992,18 +926,20 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &(uint8_t){'A'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, N,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, N,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update_fuzz]
@@ -1026,8 +962,8 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1054,8 +990,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % N;
 
         // update btree
-        int err = lfsr_btree_set(&lfs, &btree, bid, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                LFSR_ATTR(SUBMASK(DATA), 0, BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -1086,17 +1022,19 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, N,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, N,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // clean up sim
     free(sim);
@@ -1121,8 +1059,8 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_DATA, W,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1135,8 +1073,8 @@ code = '''
     }
     // update the tree
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_set(&lfs, &btree, i*W+W-1, LFSR_TAG_DATA, W,
-                LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_ATTRS(
+                LFSR_ATTR(SUBMASK(DATA), 0, BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1157,22 +1095,23 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_get(&lfs, &btree, i*W+W-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i*W+W-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == W);
         assert(memcmp(buffer, &(uint8_t){'A'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, N*W,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, N*W,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     lfs_size_t bid_ = -1;
-    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_lookupnext(&lfs, &btree, bid_+1,
                 &bid_, &tag_, &weight_, &data_) => 0;
@@ -1207,8 +1146,8 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_DATA, W,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1245,9 +1184,11 @@ code = '''
         }
 
         // update btree
-        int err = lfsr_btree_set(&lfs, &btree,
-                weighted_bid+sim_weights[bid]-1, LFSR_TAG_DATA, weight,
-                LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree,
+                weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
+                    LFSR_ATTR(SUBMASK(DATA), 0, BUF(
+                        &(uint8_t){'A'+(i % 26)}, 1)),
+                    LFSR_ATTR(GROW, +weight-sim_weights[bid], NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -1291,6 +1232,7 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < N; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -1298,20 +1240,20 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == sim_weights[i]);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, total_weight,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, total_weight,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     lfs_size_t bid_ = -1;
-    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < N; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -1356,10 +1298,11 @@ code = '''
     // create a single-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
     // pop!
-    lfsr_btree_pop(&lfs, &btree, 0) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(RM, -1, NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1370,13 +1313,14 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("A", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1384,14 +1328,15 @@ code = '''
     assert(btree.weight == 1);
 
     // try looking up tags
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "A", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_two]
@@ -1410,12 +1355,13 @@ code = '''
     // create a single-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
     // pop!
-    lfsr_btree_pop(&lfs, &btree, 1) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(RM, -1, NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1426,19 +1372,21 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
-    lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("B", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("B", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1446,20 +1394,22 @@ code = '''
     assert(btree.weight == 2);
 
     // try looking up tags
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "B", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_two_other]
@@ -1478,12 +1428,13 @@ code = '''
     // create a single-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
     // pop!
-    lfsr_btree_pop(&lfs, &btree, 0) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(RM, -1, NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1494,19 +1445,21 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "b", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("A", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1514,20 +1467,22 @@ code = '''
     assert(btree.weight == 2);
 
     // try looking up tags
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "A", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "b", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_three]
@@ -1546,14 +1501,15 @@ code = '''
     // create a single-entry tree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
-    lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("c", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("c", 1)))) => 0;
     // pop!
-    lfsr_btree_pop(&lfs, &btree, 2) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
+            LFSR_ATTR(RM, -1, NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1564,25 +1520,28 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "b", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
-    lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("C", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("C", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1590,26 +1549,29 @@ code = '''
     assert(btree.weight == 3);
 
     // try looking up tags
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "a", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "b", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 2,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 2,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "C", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, 3,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 3,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop]
@@ -1632,8 +1594,8 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1646,7 +1608,8 @@ code = '''
     }
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
-        int err = lfsr_btree_pop(&lfs, &btree, N-1-i);
+        int err = lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_ATTRS(
+                LFSR_ATTR(RM, -1, NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1668,39 +1631,43 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, REMAINING,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, REMAINING,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try recovering
-    lfsr_btree_push(&lfs, &btree, REMAINING, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("R", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("R", 1)))) => 0;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
-    lfsr_btree_get(&lfs, &btree, REMAINING,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, REMAINING,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "R", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, REMAINING+1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, REMAINING+1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_backwards]
@@ -1723,8 +1690,8 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1737,7 +1704,8 @@ code = '''
     }
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
-        int err = lfsr_btree_pop(&lfs, &btree, 0);
+        int err = lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+                LFSR_ATTR(RM, -1, NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1758,10 +1726,12 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer,
@@ -1769,30 +1739,32 @@ code = '''
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, REMAINING,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, REMAINING,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try recovering
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("R", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("R", 1)))) => 0;
 
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buffer, "R", 1) == 0);
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
-        lfsr_btree_get(&lfs, &btree, i+1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i+1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer,
                 &(uint8_t){'a'+((i+(N-REMAINING)) % 26)}, 1) == 0);
     }
 
-    lfsr_btree_get(&lfs, &btree, REMAINING+1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, REMAINING+1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_fuzz]
@@ -1816,8 +1788,8 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1845,7 +1817,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % sim_size;
 
         // remove from btree
-        int err = lfsr_btree_pop(&lfs, &btree, bid);
+        int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                LFSR_ATTR(RM, -1, NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -1877,17 +1850,19 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, sim_size,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, sim_size,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // clean up sim
     free(sim);
@@ -1914,8 +1889,8 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_DATA, W,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1928,7 +1903,8 @@ code = '''
     }
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
-        int err = lfsr_btree_pop(&lfs, &btree, (N-1-i)*W+W-1);
+        int err = lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_ATTRS(
+                LFSR_ATTR(RM, -W, NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1949,43 +1925,46 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
-        lfsr_btree_get(&lfs, &btree, i*W+W-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i*W+W-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == W);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, REMAINING*W+W-1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, REMAINING*W+W-1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try recovering
-    lfsr_btree_push(&lfs, &btree, REMAINING*W, LFSR_TAG_DATA, W,
-            LFSR_DATA_BUF("R", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +W, BUF("R", 1)))) => 0;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
-        lfsr_btree_get(&lfs, &btree, i*W+W-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i*W+W-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == W);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
-    lfsr_btree_get(&lfs, &btree, REMAINING*W+W-1,
-            &tag_, &weight_, buffer, 4) => 1;
+    lfsr_btree_lookup(&lfs, &btree, REMAINING*W+W-1,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == W);
     assert(memcmp(buffer, "R", 1) == 0);
 
-    lfsr_btree_get(&lfs, &btree, (REMAINING+1)*W+W-1,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, (REMAINING+1)*W+W-1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     lfs_size_t bid_ = -1;
-    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_lookupnext(&lfs, &btree, bid_+1,
                 &bid_, &tag_, &weight_, &data_) => 0;
@@ -2052,9 +2031,8 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        int err = lfsr_btree_push(&lfs, &btree,
-                weighted_bid, LFSR_TAG_DATA, weight,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +weight, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -2081,8 +2059,9 @@ code = '''
         }
 
         // remove from btree
-        int err = lfsr_btree_pop(&lfs, &btree,
-                weighted_bid+sim_weights[bid]-1);
+        int err = lfsr_btree_commit(&lfs, &btree,
+                weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
+                    LFSR_ATTR(RM, -sim_weights[bid], NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2128,6 +2107,7 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -2135,20 +2115,20 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == sim_weights[i]);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, total_weight,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, total_weight,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     lfs_size_t bid_ = -1;
-    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -2191,15 +2171,13 @@ code = '''
     // create a tree with N elements
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0;
     lfs_size_t n = 1;
     for (lfs_size_t i = 1; i < N; i++) {
-        int err = lfsr_btree_split(&lfs, &btree, i-1, LFSR_DATA_NULL(),
-                LFSR_TAG_DATA, 1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1),
-                LFSR_TAG_DATA, 1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS(
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)),
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+((i-0) % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2217,18 +2195,20 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < n; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, n,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, n,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_split_fuzz]
@@ -2249,8 +2229,8 @@ code = '''
     // create a btree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("_", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -2267,9 +2247,9 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % sim_size;
 
         // split btree
-        int err = lfsr_btree_split(&lfs, &btree, bid, LFSR_DATA_NULL(),
-                LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1),
-                LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'a'+(i % 26)}, 1)),
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2303,17 +2283,19 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, sim_size,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, sim_size,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // clean up sim
     free(sim);
@@ -2338,15 +2320,13 @@ code = '''
     // create a tree with N elements
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, W,
-            LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0;
     lfs_size_t n = 1;
     for (lfs_size_t i = 1; i < N; i++) {
-        int err = lfsr_btree_split(&lfs, &btree, (i-1)*W+W-1, LFSR_DATA_NULL(),
-                LFSR_TAG_DATA, W,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1),
-                LFSR_TAG_DATA, W,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS(
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)),
+                LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+((i-0) % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2364,18 +2344,20 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < n; i++) {
-        lfsr_btree_get(&lfs, &btree, i*W+W-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i*W+W-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == W);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, n*W,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, n*W,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_split_sparse_fuzz]
@@ -2397,8 +2379,8 @@ code = '''
     // create a btree
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, W,
-            LFSR_DATA_BUF("_", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +W, BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -2427,12 +2409,13 @@ code = '''
         }
 
         // split btree
-        int err = lfsr_btree_split(&lfs, &btree,
-                weighted_bid+sim_weights[bid]-1, LFSR_DATA_NULL(),
-                LFSR_TAG_DATA, weight1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1),
-                LFSR_TAG_DATA, weight2,
-                    LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree,
+                weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
+                    LFSR_ATTR(GROW, +weight1-sim_weights[bid], NULL()),
+                    LFSR_ATTR(DATA, 0, BUF(
+                        &(uint8_t){'a'+(i % 26)}, 1)),
+                    LFSR_ATTR(DATA, +weight2, BUF(
+                        &(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2459,6 +2442,7 @@ code = '''
         uint8_t buffer[4];
         lfsr_tag_t tag_;
         lfs_size_t weight_;
+        lfsr_data_t data_;
         for (lfs_size_t i = 0; i < sim_size; i++) {
             // calculate actual bid in btree space
             lfs_size_t weighted_bid = 0;
@@ -2466,8 +2450,9 @@ code = '''
                 weighted_bid += sim_weights[j];
             }
 
-            lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1,
-                    &tag_, &weight_, buffer, 4) => 1;
+            lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1,
+                    &tag_, &weight_, &data_) => 0;
+            lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
             assert(tag_ == LFSR_TAG_DATA);
             assert(weight_ == sim_weights[i]);
             assert(memcmp(buffer, &sim[i], 1) == 0);
@@ -2506,6 +2491,7 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -2513,20 +2499,20 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == sim_weights[i]);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, total_weight,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, total_weight,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     lfs_size_t bid_ = -1;
-    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -2575,25 +2561,26 @@ code = '''
     // force it to split
 
     // the extra push here avoids trying to inline the big entry
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("_", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0;
     uint8_t buf1[SIZE];
     memset(buf1, 'a', SIZE);
     uint8_t buf2[SIZE];
     memset(buf2, 'b', SIZE);
-    lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_NULL(),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf1, SIZE),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF(buf1, SIZE)),
+            LFSR_ATTR(DATA, +1, BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
-    lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF(buf2, SIZE)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF(buf2, SIZE)))) => 0;
     assert(btree.weight == 2);
 
     // now remove one entry, since this brings the rbyd down to zero,
     // this should force one of the blocks to drop
-    lfsr_btree_pop(&lfs, &btree, SIBLING) => 0;
+    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
+            LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2604,15 +2591,17 @@ code = '''
     // check that our other entry is fine
     lfsr_tag_t tag_;
     lfs_size_t weight_;
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buf1, SIZE) => SIZE;
+    lfsr_data_t data_;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0);
 
     // and check that our pop worked
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buf1, SIZE) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_drop_compact]
@@ -2638,20 +2627,20 @@ code = '''
     // force it to split
 
     // the extra push here avoids trying to inline the big entry
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("_", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0;
     uint8_t buf1[SIZE];
     memset(buf1, 'a', SIZE);
     uint8_t buf2[SIZE];
     memset(buf2, 'b', SIZE);
-    lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_NULL(),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf1, SIZE),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF(buf1, SIZE)),
+            LFSR_ATTR(DATA, +1, BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
-    lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF(buf2, SIZE)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF(buf2, SIZE)))) => 0;
     assert(btree.weight == 2);
 
     // now remove one entry, since this brings the rbyd down this zero,
@@ -2659,7 +2648,8 @@ code = '''
     //
     // do this while forcing a compaction
     btree.eoff = -1;
-    lfsr_btree_pop(&lfs, &btree, SIBLING) => 0;
+    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
+            LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2670,15 +2660,17 @@ code = '''
     // check that our other entry is fine
     lfsr_tag_t tag_;
     lfs_size_t weight_;
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buf1, SIZE) => SIZE;
+    lfsr_data_t data_;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0);
 
     // and check that our pop worked
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buf1, SIZE) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_drop_split]
@@ -2704,15 +2696,15 @@ code = '''
     // force it to split
 
     // the extra push here avoids trying to inline the big entry
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("_", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0;
     uint8_t buf1[SIZE];
     memset(buf1, 'a', SIZE);
     uint8_t buf2[SIZE];
     memset(buf2, 'b', SIZE);
-    lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_NULL(),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf1, SIZE),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF(buf1, SIZE)),
+            LFSR_ATTR(DATA, +1, BUF(buf2, SIZE)))) => 0;
 
     // force compaction, causing a split, but while we're splitting,
     // also remove an entry, bringing the split rbyd down to zero mid split
@@ -2720,7 +2712,8 @@ code = '''
     // messy, isn't it? this is why we need an explicit test
     //
     btree.eoff = -1;
-    lfsr_btree_pop(&lfs, &btree, SIBLING) => 0;
+    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
+            LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2731,15 +2724,17 @@ code = '''
     // check that our other entry is fine
     lfsr_tag_t tag_;
     lfs_size_t weight_;
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buf1, SIZE) => SIZE;
+    lfsr_data_t data_;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0);
 
     // and check that our pop worked
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buf1, SIZE) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_drop_merge]
@@ -2765,32 +2760,33 @@ code = '''
     // force it to split
 
     // the extra push here avoids trying to inline the big entry
-    lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("_", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0;
     uint8_t buf1[SIZE];
     memset(buf1, 'a', SIZE);
     uint8_t buf2[SIZE];
     memset(buf2, 'b', SIZE);
-    lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_NULL(),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf1, SIZE),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF(buf1, SIZE)),
+            LFSR_ATTR(DATA, +1, BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
-    lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF(buf2, SIZE)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF(buf2, SIZE)))) => 0;
     assert(btree.weight == 2);
 
     // now make both entries small so they should be merged if either compacts
-    lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("a", 1)) => 0;
-    lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1,
-            LFSR_DATA_BUF("b", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(SUBMASK(DATA), 0, BUF("b", 1)))) => 0;
 
     // force compaction, while removing one entry, this drops the rbyd
     // down to zero while also triggering a merge
     btree.eoff = -1;
-    lfsr_btree_pop(&lfs, &btree, SIBLING) => 0;
+    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
+            LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2801,15 +2797,17 @@ code = '''
     // check that our other entry is fine
     lfsr_tag_t tag_;
     lfs_size_t weight_;
-    lfsr_btree_get(&lfs, &btree, 0,
-            &tag_, &weight_, buf1, SIZE) => 1;
+    lfsr_data_t data_;
+    lfsr_btree_lookup(&lfs, &btree, 0,
+            &tag_, &weight_, &data_) => 0;
+    lfsr_data_read(&lfs, &data_, buf1, SIZE) => 1;
     assert(tag_ == LFSR_TAG_DATA);
     assert(weight_ == 1);
     assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0);
 
     // and check that our pop worked
-    lfsr_btree_get(&lfs, &btree, 1,
-            &tag_, &weight_, buf1, SIZE) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, 1,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 
@@ -2850,9 +2848,8 @@ code = '''
 
         if (op == 0 || bid == sim_size) {
             // push to btree
-            int err = lfsr_btree_push(&lfs, &btree, bid,
-                    LFSR_TAG_DATA, 1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+            int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                    LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -2866,9 +2863,9 @@ code = '''
 
         } else if (op == 1) {
             // update btree
-            int err = lfsr_btree_set(&lfs, &btree, bid,
-                    LFSR_TAG_DATA, 1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+            int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                    LFSR_ATTR(SUBMASK(DATA), 0, BUF(
+                        &(uint8_t){'a'+(i % 26)}, 1))));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -2880,7 +2877,8 @@ code = '''
 
         } else {
             // pop from btree
-            int err = lfsr_btree_pop(&lfs, &btree, bid);
+            int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                    LFSR_ATTR(RM, -1, NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -2913,17 +2911,19 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, sim_size,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, sim_size,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // clean up sim
     free(sim);
@@ -2976,9 +2976,9 @@ code = '''
 
         if (op == 0 || bid == sim_size) {
             // push to btree
-            int err = lfsr_btree_push(&lfs, &btree, weighted_bid,
-                    LFSR_TAG_DATA, weight,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+            int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
+                    LFSR_ATTR(DATA, +weight, BUF(
+                        &(uint8_t){'a'+(i % 26)}, 1))));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -2995,9 +2995,11 @@ code = '''
 
         } else if (op == 1) {
             // update btree
-            int err = lfsr_btree_set(&lfs, &btree,
-                    weighted_bid+sim_weights[bid]-1, LFSR_TAG_DATA, weight,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+            int err = lfsr_btree_commit(&lfs, &btree,
+                    weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
+                        LFSR_ATTR(SUBMASK(DATA), 0, BUF(
+                            &(uint8_t){'a'+(i % 26)}, 1)),
+                        LFSR_ATTR(GROW, +weight-sim_weights[bid], NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -3010,8 +3012,9 @@ code = '''
 
         } else {
             // remove from btree
-            int err = lfsr_btree_pop(&lfs, &btree,
-                    weighted_bid+sim_weights[bid]-1);
+            int err = lfsr_btree_commit(&lfs, &btree,
+                    weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
+                        LFSR_ATTR(RM, -sim_weights[bid], NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -3058,6 +3061,7 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -3065,20 +3069,20 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == sim_weights[i]);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, total_weight,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, total_weight,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     lfs_size_t bid_ = -1;
-    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
         // calculate actual bid in btree space
         lfs_size_t weighted_bid = 0;
@@ -3210,10 +3214,12 @@ code = '''
             LFSR_ATTR(NAME, +1,
                 CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
             LFSR_ATTR(DATA, 0, BUF("0", 1)))) => 0;
-    lfsr_btree_split(&lfs, &btree, 0,
-            LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aab", 3)),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF("0", 1)),
+            LFSR_ATTR(NAME, +1, CAT(
+                LFSR_DATA_LEB128(0),
+                LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(DATA, 0, BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3274,14 +3280,18 @@ code = '''
             LFSR_ATTR(NAME, +1,
                 CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
             LFSR_ATTR(DATA, 0, BUF("0", 1)))) => 0;
-    lfsr_btree_split(&lfs, &btree, 0,
-            LFSR_DATA_CAT(LFSR_DATA_LEB128(1*DID), LFSR_DATA_BUF("aab", 3)),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0;
-    lfsr_btree_split(&lfs, &btree, 1,
-            LFSR_DATA_CAT(LFSR_DATA_LEB128(2*DID), LFSR_DATA_BUF("aac", 3)),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("2", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF("0", 1)),
+            LFSR_ATTR(NAME, +1, CAT(
+                LFSR_DATA_LEB128(1*DID),
+                LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(DATA, 0, BUF("1", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF("1", 1)),
+            LFSR_ATTR(NAME, +1, CAT(
+                LFSR_DATA_LEB128(2*DID),
+                LFSR_DATA_BUF("aac", 3))),
+            LFSR_ATTR(DATA, 0, BUF("2", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3350,14 +3360,18 @@ code = '''
             LFSR_ATTR(NAME, +1,
                 CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
             LFSR_ATTR( DATA, 0, BUF("0", 1)))) => 0;
-    lfsr_btree_split(&lfs, &btree, 0,
-            LFSR_DATA_CAT(LFSR_DATA_LEB128(2*DID), LFSR_DATA_BUF("aac", 3)),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("2", 1)) => 0;
-    lfsr_btree_split(&lfs, &btree, 0,
-            LFSR_DATA_CAT(LFSR_DATA_LEB128(1*DID), LFSR_DATA_BUF("aab", 3)),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1),
-            LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF("1", 1)),
+            LFSR_ATTR(NAME, +1, CAT(
+                LFSR_DATA_LEB128(2*DID),
+                LFSR_DATA_BUF("aac", 3))),
+            LFSR_ATTR(DATA, 0, BUF("2", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
+            LFSR_ATTR(DATA, 0, BUF("0", 1)),
+            LFSR_ATTR(NAME, +1, CAT(
+                LFSR_DATA_LEB128(1*DID),
+                LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(DATA, 0, BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3435,12 +3449,12 @@ code = '''
         char name[3] = {
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
-        int err = lfsr_btree_split(&lfs, &btree, i-1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(i*DID), LFSR_DATA_BUF(name, 3)),
-                LFSR_TAG_DATA, 1,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1),
-                LFSR_TAG_DATA, 1,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS(
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
+                LFSR_ATTR(NAME, +1, CAT(
+                    LFSR_DATA_LEB128(i*DID),
+                    LFSR_DATA_BUF(name, 3))),
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -3530,10 +3544,12 @@ code = '''
         }
 
         // split btree
-        int err = lfsr_btree_split(&lfs, &btree, bid,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3)),
-                LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1),
-                LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)),
+                LFSR_ATTR(NAME, +1, CAT(
+                    LFSR_DATA_LEB128(0),
+                    LFSR_DATA_BUF(name, 3))),
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -3619,12 +3635,12 @@ code = '''
         char name[3] = {
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
-        int err = lfsr_btree_split(&lfs, &btree, (i-1)*W+W-1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(i*DID), LFSR_DATA_BUF(name, 3)),
-                LFSR_TAG_DATA, W,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1),
-                LFSR_TAG_DATA, W,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS(
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
+                LFSR_ATTR(NAME, +W, CAT(
+                    LFSR_DATA_LEB128(i*DID),
+                    LFSR_DATA_BUF(name, 3))),
+                LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -3727,13 +3743,14 @@ code = '''
         }
 
         // split btree
-        int err = lfsr_btree_split(&lfs, &btree,
-                weighted_bid+sim_weights[bid]-1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3)),
-                LFSR_TAG_DATA, weight1,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1),
-                LFSR_TAG_DATA, weight2,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree,
+                weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
+                    LFSR_ATTR(GROW, +weight1-sim_weights[bid], NULL()),
+                    LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)),
+                    LFSR_ATTR(NAME, +weight2, CAT(
+                        LFSR_DATA_LEB128(0),
+                        LFSR_DATA_BUF(name, 3))),
+                    LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -3894,13 +3911,12 @@ code = '''
                 }
                 assert(err == 0);
             } else {
-                int err = lfsr_btree_split(&lfs, &btree,
-                        split_bid, LFSR_DATA_CAT(
+                int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
+                        LFSR_ATTR(DATA, 0, DATA( split_data)),
+                        LFSR_ATTR(NAME, +1, CAT(
                             LFSR_DATA_LEB128(0),
-                            LFSR_DATA_BUF(name, 3)),
-                        LFSR_TAG_DATA, 1, split_data,
-                        LFSR_TAG_DATA, 1,
-                            LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1));
+                            LFSR_DATA_BUF(name, 3))),
+                        LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1))));
                 // ignore space issues
                 if (err == LFS_ERR_NOSPC) {
                     break;
@@ -3917,9 +3933,9 @@ code = '''
 
         } else if (op == 1) {
             // update btree
-            int err = lfsr_btree_set(&lfs, &btree, bid,
-                    LFSR_TAG_DATA, 1,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1));
+            int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                    LFSR_ATTR(SUBMASK(DATA), 0, BUF(
+                        &(uint8_t){'0'+(i % 10)}, 1))));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -3931,7 +3947,8 @@ code = '''
 
         } else {
             // pop from btree
-            int err = lfsr_btree_pop(&lfs, &btree, bid);
+            int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                    LFSR_ATTR(RM, -1, NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -4064,9 +4081,10 @@ code = '''
             if (lfs_cmp(cmp) > 0) {
                 int err = lfsr_btree_commit(&lfs, &btree,
                         split_bid-(split_weight-1), LFSR_ATTRS(
-                            LFSR_ATTR(NAME, +weight, CAT(
-                                LFSR_DATA_LEB128(0),
-                                LFSR_DATA_BUF(name, 3))),
+                            LFSR_ATTR(
+                                NAME, +weight, CAT(
+                                    LFSR_DATA_LEB128(0),
+                                    LFSR_DATA_BUF(name, 3))),
                             LFSR_ATTR(
                                 DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1))));
                 // ignore space issues
@@ -4075,14 +4093,13 @@ code = '''
                 }
                 assert(err == 0);
             } else {
-                int err = lfsr_btree_split(&lfs, &btree, split_bid,
-                        LFSR_DATA_CAT(
+                int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
+                        LFSR_ATTR(DATA, 0, DATA(
+                            split_data)),
+                        LFSR_ATTR(NAME, +weight, CAT(
                             LFSR_DATA_LEB128(0),
-                            LFSR_DATA_BUF(name, 3)),
-                        LFSR_TAG_DATA, split_weight,
-                            split_data,
-                        LFSR_TAG_DATA, weight,
-                            LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1));
+                            LFSR_DATA_BUF(name, 3))),
+                        LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1))));
                 // ignore space issues
                 if (err == LFS_ERR_NOSPC) {
                     break;
@@ -4102,9 +4119,11 @@ code = '''
 
         } else if (op == 1) {
             // update btree
-            int err = lfsr_btree_set(&lfs, &btree,
-                    weighted_bid+sim_weights[bid]-1, LFSR_TAG_DATA, weight,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1));
+            int err = lfsr_btree_commit(&lfs, &btree,
+                    weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
+                        LFSR_ATTR(SUBMASK(DATA), 0, BUF(
+                            &(uint8_t){'0'+(i % 10)}, 1)),
+                        LFSR_ATTR(GROW, +weight-sim_weights[bid], NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -4117,8 +4136,9 @@ code = '''
 
         } else {
             // pop from btree
-            int err = lfsr_btree_pop(&lfs, &btree,
-                    weighted_bid+sim_weights[bid]-1);
+            int err = lfsr_btree_commit(&lfs, &btree,
+                    weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
+                        LFSR_ATTR(RM, -sim_weights[bid], NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -4216,8 +4236,8 @@ code = '''
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfs_size_t n = 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -4235,18 +4255,20 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
 
     for (lfs_size_t i = 0; i < n; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, n,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, n,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // test that we can traverse the tree, keeping track of all blocks we see
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
@@ -4306,16 +4328,17 @@ code = '''
 
     // check that the elements are in the tree
     for (lfs_size_t i = 0; i < n; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
     // and check that we can't lookup elements that aren't in the tree
-    lfsr_btree_get(&lfs, &btree, n,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, n,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_traversal_fuzz]
@@ -4351,8 +4374,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1);
 
         // add to btree
-        int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_DATA, 1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1));
+        int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
+                LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -4385,17 +4408,19 @@ code = '''
     uint8_t buffer[4];
     lfsr_tag_t tag_;
     lfs_size_t weight_;
+    lfsr_data_t data_;
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, sim_size,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, sim_size,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // test that we can traverse the tree, keeping track of all blocks
     // we see
@@ -4472,16 +4497,17 @@ code = '''
     assert(btree.weight == sim_size);
 
     for (lfs_size_t i = 0; i < sim_size; i++) {
-        lfsr_btree_get(&lfs, &btree, i,
-                &tag_, &weight_, buffer, 4) => 1;
+        lfsr_btree_lookup(&lfs, &btree, i,
+                &tag_, &weight_, &data_) => 0;
+        lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
         assert(tag_ == LFSR_TAG_DATA);
         assert(weight_ == 1);
         assert(memcmp(buffer, &sim[i], 1) == 0);
     }
 
     // and no extra elements
-    lfsr_btree_get(&lfs, &btree, sim_size,
-            &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_btree_lookup(&lfs, &btree, sim_size,
+            &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // clean up sim
     free(sim);
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index caff773b..aabcff8d 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -5,21 +5,6 @@ after = ['test_rbyd', 'test_btree']
 # of the disk for these tests
 defines.LOOKAHEAD_SIZE = 'BLOCK_COUNT / 8'
 
-# some helper functions
-in = 'lfs.c'
-code = '''
-    static lfs_ssize_t lfsr_mdir_get(lfs_t *lfs, const lfsr_mdir_t *mdir,
-            lfsr_tag_t tag, void *buffer, lfs_size_t size) {
-        lfsr_data_t data;
-        int err = lfsr_mdir_lookup(lfs, mdir, tag, &data);
-        if (err) {
-            return err;
-        }
-
-        return lfsr_data_read(lfs, &data, buffer, size);
-    }
-'''
-
 # test a single mroot
 [cases.test_mtree_mroot]
 code = '''
@@ -45,9 +30,10 @@ code = '''
     }
 
     for (lfs_size_t i = 0; i < N; i++) {
+        lfsr_data_t data;
         uint8_t buffer[1];
-        lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i),
-                buffer, 1) => 1;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i), &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 1) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
@@ -58,9 +44,10 @@ code = '''
     lfsr_mount(&lfs, CFG) => 0;
 
     for (lfs_size_t i = 0; i < N; i++) {
+        lfsr_data_t data;
         uint8_t buffer[1];
-        lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i),
-                buffer, 1) => 1;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i), &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 1) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
@@ -87,9 +74,10 @@ code = '''
     }
 
     for (lfs_size_t i = 0; i < N; i++) {
+        lfsr_data_t data;
         uint8_t buffer[1];
-        lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i),
-                buffer, 1) => 1;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i), &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 1) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
@@ -100,9 +88,10 @@ code = '''
     lfsr_mount(&lfs, CFG) => 0;
 
     for (lfs_size_t i = 0; i < N; i++) {
+        lfsr_data_t data;
         uint8_t buffer[1];
-        lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i),
-                buffer, 1) => 1;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i), &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 1) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
 
@@ -123,16 +112,18 @@ code = '''
         lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
                 LFSR_ATTR(
                     UATTR(1), 0, BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+        lfsr_data_t data;
 
         uint8_t buffer[4];
-        lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-                buffer, 4) => 1;
+        lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 4) => 1;
         assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0);
     }
+    lfsr_data_t data;
 
     uint8_t buffer[4];
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, 4) => 1;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 1;
     assert(memcmp(buffer, &(uint8_t){'a'+((N-1) % 26)}, 1) == 0);
 
     lfsr_unmount(&lfs) => 0;
@@ -141,8 +132,8 @@ code = '''
     // check things stay sane after remount
     lfsr_mount(&lfs, CFG) => 0;
 
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, 4) => 1;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 1;
     assert(memcmp(buffer, &(uint8_t){'a'+((N-1) % 26)}, 1) == 0);
 
     lfsr_unmount(&lfs) => 0;
@@ -161,6 +152,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create a 2 large attrs that needs to be uninlined
     uint8_t buffer[SIZE];
@@ -184,14 +176,14 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attrs are still in the mroot/mtree
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
     // check things stay sane after remount
@@ -204,14 +196,14 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attrs are still in the mroot/mtree
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -226,6 +218,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -255,14 +248,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     // check things stay sane after remount
@@ -277,14 +270,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -299,6 +292,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -344,20 +338,20 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
     // check things stay sane after remount
@@ -372,20 +366,20 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
     lfsr_unmount(&lfs) => 0;
@@ -418,26 +412,28 @@ code = '''
         }
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
                 LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0;
+        lfsr_data_t data;
 
         uint8_t buffer[256];
-        lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                buffer, sizeof(buffer)) => 4;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
 
     // try looking up each entry
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
+    lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
         sprintf(name+1, "%03x", i);
         lfsr_mtree_seek(&lfs, &mdir, +1) => 0;
-        lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                buffer, sizeof(buffer)) => 4;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
 
@@ -447,15 +443,15 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
         sprintf(name+1, "%03x", i);
         lfsr_mtree_seek(&lfs, &mdir, +1) => 0;
-        lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                buffer, sizeof(buffer)) => 4;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
 
@@ -505,20 +501,22 @@ code = '''
         }
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
                 LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0;
+        lfsr_data_t data;
 
         // double check
         uint8_t buffer[256];
-        lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                buffer, sizeof(buffer)) => 4;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
 
     // try looking up each entry
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
+    lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
@@ -526,8 +524,8 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
@@ -541,8 +539,8 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
@@ -550,8 +548,8 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
@@ -575,6 +573,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -616,8 +615,8 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     // check things stay sane after remount
@@ -632,8 +631,8 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
@@ -648,6 +647,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -691,8 +691,8 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     // check things stay sane after remount
@@ -707,8 +707,8 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
@@ -723,6 +723,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -758,8 +759,8 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     // check things stay sane after remount
@@ -774,8 +775,8 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
@@ -790,6 +791,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -840,14 +842,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
     // check things stay sane after remount
@@ -862,14 +864,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
     lfsr_unmount(&lfs) => 0;
@@ -884,6 +886,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -934,14 +937,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     // check things stay sane after remount
@@ -956,14 +959,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -1015,11 +1018,12 @@ code = '''
             }
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
                     LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0;
+            lfsr_data_t data;
 
             // double check
             uint8_t buffer[256];
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
 
         // delete
@@ -1048,9 +1052,10 @@ code = '''
     // try looking up each entry
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
+    lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
@@ -1058,8 +1063,8 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
@@ -1073,8 +1078,8 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
@@ -1082,8 +1087,8 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
@@ -1109,6 +1114,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create a 2 large attrs that needs to be uninlined
     uint8_t buffer[SIZE];
@@ -1149,14 +1155,14 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attrs are still in the mroot/mtree
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
     // check things stay sane after remount
@@ -1169,14 +1175,14 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attrs are still in the mroot/mtree
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -1193,6 +1199,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -1241,14 +1248,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     // check things stay sane after remount
@@ -1263,14 +1270,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -1287,6 +1294,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -1335,14 +1343,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     // check things stay sane after remount
@@ -1357,14 +1365,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -1381,6 +1389,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // prepare mroot with an entry
     uint8_t buffer[SIZE];
@@ -1404,8 +1413,8 @@ code = '''
     // assert that our entry is still in the mroot
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     // check things stay sane after remount
@@ -1415,8 +1424,8 @@ code = '''
     // assert that our attr is still in the mroot
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
@@ -1436,6 +1445,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // prepare mroot with an entry
     uint8_t buffer[SIZE];
@@ -1473,8 +1483,8 @@ code = '''
     // assert that our attr is still in the mroot
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     // check things stay sane after remount
@@ -1484,8 +1494,8 @@ code = '''
     // assert that our attr is still in the mroot
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
@@ -1502,6 +1512,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // prepare mroot with an entry
     uint8_t buffer[SIZE];
@@ -1534,8 +1545,8 @@ code = '''
     // assert that our entry is still in the mroot
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     // check things stay sane after remount
@@ -1545,8 +1556,8 @@ code = '''
     // assert that our attr is still in the mroot
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
@@ -1563,6 +1574,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -1616,14 +1628,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     // check things stay sane after remount
@@ -1638,14 +1650,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -1662,6 +1674,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -1719,20 +1732,20 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
     // check things stay sane after remount
@@ -1747,20 +1760,20 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
     lfsr_unmount(&lfs) => 0;
@@ -1777,6 +1790,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -1829,8 +1843,8 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     // check things stay sane after remount
@@ -1845,8 +1859,8 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
@@ -1868,6 +1882,7 @@ code = '''
     // trigger a relocation
     lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
+    lfsr_data_t data;
 
     // create a 2 large attrs that needs to be uninlined
     uint8_t buffer[SIZE];
@@ -1894,14 +1909,14 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attrs are still in the mroot/mtree
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
     // check things stay sane after remount
@@ -1914,14 +1929,14 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attrs are still in the mroot/mtree
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -1943,6 +1958,7 @@ code = '''
     // trigger a relocation
     lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -1975,14 +1991,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     // check things stay sane after remount
@@ -1997,14 +2013,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -2058,11 +2074,12 @@ code = '''
             }
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
                     LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0;
+            lfsr_data_t data;
 
             // double check
             uint8_t buffer[256];
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
 
         // update
@@ -2086,11 +2103,12 @@ code = '''
             // trigger writes to the mdir
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
                     LFSR_ATTR(REG, 0, BUF(name, 4)))) => 0;
+            lfsr_data_t data;
 
             // double check
             uint8_t buffer[256];
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
 
         // delete
@@ -2119,9 +2137,10 @@ code = '''
     // try looking up each entry
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
+    lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
@@ -2129,8 +2148,8 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
@@ -2144,8 +2163,8 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
@@ -2153,8 +2172,8 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
@@ -2197,11 +2216,12 @@ code = '''
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(REG, +1, BUF("\0b", 2)))) => 0;
+    lfsr_data_t data;
 
     // assert our entry was created
     uint8_t buffer[2];
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, 2) => 2;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 2) => 2;
     assert(buffer[1] == 'b');
 
     // assert that our neighbors were updated correctly
@@ -2950,6 +2970,7 @@ code = '''
         }
     }
     free(seen);
+    lfsr_data_t data;
 
     // and the tree should still work
 
@@ -2957,8 +2978,8 @@ code = '''
     uint8_t buffer[256];
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, sizeof(buffer)) => 2;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2;
     assert(memcmp(buffer, "\0a", 2) == 0);
 
     // check things stay sane after remount
@@ -2968,8 +2989,8 @@ code = '''
     // assert that our entry is still in the mtree
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, sizeof(buffer)) => 2;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2;
     assert(memcmp(buffer, "\0a", 2) == 0);
 
     lfsr_unmount(&lfs) => 0;
@@ -2985,6 +3006,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create a 2 large attrs that needs to be uninlined
     uint8_t buffer[SIZE];
@@ -3071,14 +3093,14 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attrs are still in the mroot/mtree
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
     // check things stay sane after remount
@@ -3091,14 +3113,14 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attrs are still in the mroot/mtree
-    lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
 
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -3114,6 +3136,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -3206,14 +3229,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     // check things stay sane after remount
@@ -3228,14 +3251,14 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_unmount(&lfs) => 0;
@@ -3251,6 +3274,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // create 2 large entries that needs to be uninlined and split
     uint8_t buffer[SIZE];
@@ -3359,20 +3383,20 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
     // check things stay sane after remount
@@ -3387,20 +3411,20 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
     assert(mdir.rbyd.weight == 1);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
 
     lfsr_unmount(&lfs) => 0;
@@ -3488,6 +3512,7 @@ code = '''
         }
     }
     free(seen);
+    lfsr_data_t data;
 
     // and the tree should still work
 
@@ -3495,8 +3520,8 @@ code = '''
     uint8_t buffer[256];
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, sizeof(buffer)) => 2;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2;
     assert(memcmp(buffer, "\0a", 2) == 0);
 
     // check things stay sane after remount
@@ -3506,8 +3531,8 @@ code = '''
     // assert that our entry is still in the mtree
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, sizeof(buffer)) => 2;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2;
     assert(memcmp(buffer, "\0a", 2) == 0);
 
     lfsr_unmount(&lfs) => 0;
@@ -3540,10 +3565,11 @@ code = '''
         }
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
                 LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0;
+        lfsr_data_t data;
 
         uint8_t buffer[256];
-        lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                buffer, sizeof(buffer)) => 4;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
 
@@ -3608,16 +3634,17 @@ code = '''
     // try looking up each entry
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
+    lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
         sprintf(name+1, "%03x", i);
         lfsr_mtree_seek(&lfs, &mdir, +1) => 0;
-        lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                buffer, sizeof(buffer)) => 4;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
 
@@ -3627,15 +3654,15 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
         sprintf(name+1, "%03x", i);
         lfsr_mtree_seek(&lfs, &mdir, +1) => 0;
-        lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                buffer, sizeof(buffer)) => 4;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
 
@@ -3685,11 +3712,12 @@ code = '''
         }
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
                 LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0;
+        lfsr_data_t data;
 
         // double check
         uint8_t buffer[256];
-        lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                buffer, sizeof(buffer)) => 4;
+        lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
         assert(memcmp(buffer, name, 4) == 0);
     }
 
@@ -3755,9 +3783,10 @@ code = '''
     // try looking up each entry
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
+    lfsr_data_t data;
     uint8_t buffer[256];
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
@@ -3765,8 +3794,8 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
@@ -3780,8 +3809,8 @@ code = '''
 
     // try looking up each entry
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
-            buffer, sizeof(buffer)) => 1;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1;
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         name[0] = '\0';
@@ -3789,8 +3818,8 @@ code = '''
         if (sim[i]) {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
                     &mdir, NULL, NULL) => 0;
-            lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-                    buffer, sizeof(buffer)) => 4;
+            lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4;
             assert(memcmp(buffer, name, 4) == 0);
         } else {
             lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
@@ -3885,6 +3914,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // prepare mroot with an entry
     uint8_t buffer[SIZE];
@@ -3908,8 +3938,8 @@ code = '''
     // assert that our entry is still in the mroot
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
@@ -3940,6 +3970,7 @@ code = '''
     lfsr_format(&lfs, CFG) => 0;
     lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
+    lfsr_data_t data;
 
     // prepare mroot with an entry
     uint8_t buffer[SIZE];
@@ -3977,8 +4008,8 @@ code = '''
     // assert that our attr is still in the mroot
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
-    lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
-            buffer, SIZE) => SIZE;
+    lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfsr_unmount(&lfs) => 0;
diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml
index 982f053e..fb55dbbc 100644
--- a/tests/test_rbyd.toml
+++ b/tests/test_rbyd.toml
@@ -13,22 +13,6 @@ defines.ERASE_VALUE = [0xff, 0x00, 0x1b]
 # waste time when testing
 defines.BLOCK_SIZE = 32768
 
-# TODO we should eventually replace these with lfsr_rbyd_lookup
-# some internal helpers
-in = 'lfs.c'
-code = '''
-    static lfs_ssize_t lfsr_rbyd_get(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
-            lfs_ssize_t rid, lfsr_tag_t tag, void *buffer, lfs_size_t size) {
-        lfsr_data_t data;
-        int err = lfsr_rbyd_lookup(lfs, rbyd, rid, tag, &data);
-        if (err) {
-            return err;
-        }
-
-        return lfsr_data_read(lfs, &data, buffer, size);
-    }
-'''
-
 [cases.test_rbyd_atomic_commit]
 in = 'lfs.c'
 code = '''
@@ -363,6 +347,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // commit with one attribute
@@ -371,18 +356,18 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
+            &data) => LFS_ERR_NOENT;
 
     // commit with two attributes
     rbyd = init_rbyd;
@@ -391,20 +376,20 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
+            &data) => LFS_ERR_NOENT;
 
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
@@ -412,20 +397,20 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
+            &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_get]
@@ -442,6 +427,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // commit with one attribute
@@ -450,18 +436,18 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
+            &data) => LFS_ERR_NOENT;
 
     // commit with two attributes
     rbyd = init_rbyd;
@@ -471,20 +457,20 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
+            &data) => LFS_ERR_NOENT;
 
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
@@ -493,20 +479,20 @@ code = '''
             LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
-            => 4;
-    lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
+            &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_bifoliate]
@@ -3581,6 +3567,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     printf("perm: [");
@@ -3645,9 +3632,10 @@ code = '''
     printf("rbyd: [");
     first = true;
     for (unsigned attr = 0; attr < N; attr++) {
-        lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd,
-                -1, LFSR_TAG_UATTR(attr), buffer, 4);
-        if (size >= 0) {
+        int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(attr),
+                &data);
+        if (!err) {
+            lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
             if (!first) {
                 printf(", ");
             }
@@ -3658,13 +3646,15 @@ code = '''
     printf("]\n");
 
     for (unsigned attr = 0; attr < N; attr++) {
-        lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd,
-                -1, LFSR_TAG_UATTR(attr), buffer, 4);
+        int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(attr),
+                &data);
         if (sim[attr]) {
+            assert(!err);
+            lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
             assert(size == 1);
             assert(memcmp(&sim[attr], buffer, 1) == 0);
         } else {
-            assert(size == LFS_ERR_NOENT);
+            assert(err == LFS_ERR_NOENT);
         }
     }
 
@@ -3689,6 +3679,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // try to create one rid
@@ -3698,12 +3689,14 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
     // try to create two ids
@@ -3714,16 +3707,20 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     // create a third to the right
@@ -3735,20 +3732,26 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 '''
 
@@ -3766,6 +3769,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // try to create one rid
@@ -3775,14 +3779,14 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
     // try to create two ids
@@ -3794,16 +3798,20 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     // try to create two in the other direction
@@ -3815,16 +3823,20 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
     // create a third to the right
@@ -3838,20 +3850,26 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     // create a third to the left
@@ -3865,20 +3883,26 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     // create a third in the middle
@@ -3892,20 +3916,26 @@ code = '''
             LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 '''
 
@@ -3937,6 +3967,7 @@ code = '''
         "\xee\xee\xee\xee",
         "\xff\xff\xff\xff",
     };
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // keep track of the worst case log size
@@ -3981,8 +4012,9 @@ code = '''
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_get(&lfs, &rbyd,
-                    j, LFSR_TAG_REG, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd,
+                    j, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
 
@@ -4025,6 +4057,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // traverse requires correct biasing of the weights in the rbyd tree
@@ -4041,14 +4074,16 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4059,14 +4094,16 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4089,6 +4126,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // traverse requires correct biasing of the weights in the rbyd tree
@@ -4106,14 +4144,16 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4124,14 +4164,16 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4149,14 +4191,16 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4167,14 +4211,16 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4211,6 +4257,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -4260,7 +4307,8 @@ code = '''
             assert(rid_ == j);
             assert(lfsr_data_size(&data_) == 4);
 
-            lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
         lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -4355,6 +4403,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // try to create one rid
@@ -4365,16 +4414,20 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa",         2)))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
     // try to create two ids
@@ -4387,24 +4440,32 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb",         2)))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     // create a third to the right
@@ -4419,49 +4480,67 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc",         2)))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 '''
 
@@ -4479,6 +4558,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // try to create one rid
@@ -4490,16 +4570,20 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa",         2)))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
     // try to create two ids
@@ -4515,24 +4599,32 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb",         2)))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     // try to create two in the other direction
@@ -4548,24 +4640,32 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa",         2)))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
     // create a third to the right
@@ -4585,49 +4685,67 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc",         2)))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     // create a third to the left
@@ -4647,32 +4765,44 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa",         2)))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     // create a third in the middle
@@ -4692,32 +4822,44 @@ code = '''
             LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb",         2)))) => 0;
 
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 '''
 
@@ -4750,6 +4892,7 @@ code = '''
         "\xee\xee\xee\xee",
         "\xff\xff\xff\xff",
     };
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // keep track of the worst case log size
@@ -4800,12 +4943,14 @@ code = '''
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1), buffer, 4)
-                        => 2;
+                lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1),
+                        &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                 assert(memcmp(buffer, names[j % 6], 2) == 0);
             }
         }
@@ -4849,6 +4994,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // traverse requires correct biasing of the weights in the rbyd tree
@@ -4867,28 +5013,32 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4899,28 +5049,32 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4943,6 +5097,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // traverse requires correct biasing of the weights in the rbyd tree
@@ -4964,28 +5119,32 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -4996,28 +5155,32 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -5039,28 +5202,32 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -5071,28 +5238,32 @@ code = '''
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 0);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 4);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
     assert(rid_ == 1);
     assert(lfsr_data_size(&data_) == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -5130,6 +5301,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -5186,7 +5358,8 @@ code = '''
             assert(rid_ == j);
             assert(lfsr_data_size(&data_) == 4);
 
-            lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
@@ -5196,7 +5369,8 @@ code = '''
                 assert(rid_ == j);
                 assert(lfsr_data_size(&data_) == 2);
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                 assert(memcmp(buffer, names[j % 6], 2) == 0);
             }
         }
@@ -5236,6 +5410,7 @@ code = '''
         "\xff\xff\xff\xff",
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // keep track of the worst case log size
@@ -5300,12 +5475,14 @@ code = '''
         // check that all tags have been updated
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1), buffer, 4)
-                        => 3;
+                lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1),
+                        &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 3;
                 assert(memcmp(buffer, names[j % 6], 3) == 0);
             }
         }
@@ -5369,6 +5546,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // keep track of the worst case log size
@@ -5440,7 +5618,8 @@ code = '''
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
-                lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_REG, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
                 for (unsigned u = 0; u < M; u++) {
@@ -5467,7 +5646,8 @@ code = '''
                         assert(rid_ == k);
                         assert(lfsr_data_size(&data_) == 2);
 
-                        lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                        lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                         assert(memcmp(buffer, names[k % 6], 2) == 0);
                     }
                 }
@@ -5481,7 +5661,8 @@ code = '''
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
-                lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_REG, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
                 for (unsigned u = 0; u < M; u++) {
@@ -5493,14 +5674,16 @@ code = '''
                         assert(rid_ == k);
                         assert(lfsr_data_size(&data_) == 3);
 
-                        lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 3;
+                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                        lfsr_data_read(&lfs, &data, buffer, 4) => 3;
                         assert(memcmp(buffer, names[k % 6], 3) == 0);
                     } else {
                         assert(tag_ == LFSR_TAG_UATTR(u+1));
                         assert(rid_ == k);
                         assert(lfsr_data_size(&data_) == 2);
 
-                        lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+                        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                        lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                         assert(memcmp(buffer, names[k % 6], 2) == 0);
                     }
                 }
@@ -5563,6 +5746,7 @@ code = '''
         "\xff\xff\xff\xff",
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // keep track of the worst case log size
@@ -5627,12 +5811,13 @@ code = '''
         // check that all tags have been removed
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1), buffer, 4)
-                        => LFS_ERR_NOENT;
+                lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1),
+                        &data) => LFS_ERR_NOENT;
             }
         }
 
@@ -5778,6 +5963,7 @@ code = '''
         "\xee\xee\xee\xee",
         "\xff\xff\xff\xff",
     };
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // keep track of the worst case log size
@@ -5829,13 +6015,15 @@ code = '''
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_get(&lfs, &rbyd,
-                    -1, LFSR_TAG_UATTR(j+1), buffer, 4) => 1;
+            lfsr_rbyd_lookup(&lfs, &rbyd,
+                    -1, LFSR_TAG_UATTR(j+1), &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_get(&lfs, &rbyd,
-                    j, LFSR_TAG_REG, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd,
+                    j, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
 
@@ -5850,7 +6038,8 @@ code = '''
             assert(rid_ == -1);
             assert(lfsr_data_size(&data_) == 1);
 
-            lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 1;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &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++) {
@@ -5860,7 +6049,8 @@ code = '''
             assert(rid_ == j);
             assert(lfsr_data_size(&data_) == 4);
 
-            lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
         lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -5917,6 +6107,7 @@ code = '''
         "\xee\xee\xee\xee",
         "\xff\xff\xff\xff",
     };
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // keep track of the worst case log size
@@ -5973,17 +6164,20 @@ code = '''
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_get(&lfs, &rbyd,
-                    -1, LFSR_TAG_UATTR(j+1), buffer, 4) => 1;
+            lfsr_rbyd_lookup(&lfs, &rbyd,
+                    -1, LFSR_TAG_UATTR(j+1), &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_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1), buffer, 4)
-                        => 2;
+                lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1),
+                        &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                 assert(memcmp(buffer, names[j % 6], 2) == 0);
             }
         }
@@ -5999,7 +6193,8 @@ code = '''
             assert(rid_ == -1);
             assert(lfsr_data_size(&data_) == 1);
 
-            lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 1;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &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++) {
@@ -6009,7 +6204,8 @@ code = '''
             assert(rid_ == j);
             assert(lfsr_data_size(&data_) == 4);
 
-            lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             for (unsigned u = 0; u < M; u++) {
@@ -6019,7 +6215,8 @@ code = '''
                 assert(rid_ == j);
                 assert(lfsr_data_size(&data_) == 2);
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                 assert(memcmp(buffer, names[j % 6], 2) == 0);
             }
         }
@@ -6065,6 +6262,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // try to delete one rid
@@ -6077,15 +6275,19 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // try to delete the other rid
     rbyd = init_rbyd;
@@ -6097,15 +6299,19 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // try to delete the largest of three
     rbyd = init_rbyd;
@@ -6118,17 +6324,23 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // try to delete the smallest of three
     rbyd = init_rbyd;
@@ -6141,17 +6353,23 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // try to delete the middle
     rbyd = init_rbyd;
@@ -6164,17 +6382,23 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 '''
 
 [cases.test_rbyd_delete_range]
@@ -6191,6 +6415,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // try to delete one rid
@@ -6205,29 +6430,29 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     // try to delete the other rid
     rbyd = init_rbyd;
@@ -6241,29 +6466,29 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     // try to delete the largest of three
     rbyd = init_rbyd;
@@ -6279,40 +6504,41 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     // try to delete the smallest of three
     rbyd = init_rbyd;
@@ -6328,41 +6554,41 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     // try to delete the middle
     rbyd = init_rbyd;
@@ -6378,41 +6604,41 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4)
-            => 4;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_REG, &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
-            => 2;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), &data) => 0;
+    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
-    lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1),
+            &data) => LFS_ERR_NOENT;
 '''
 
 # NOTE if we separate physical/logical block sizes we may be able to
@@ -6445,6 +6671,7 @@ code = '''
         "\xee\xee\xee\xee\xee\xee",
         "\xff\xff\xff\xff\xff\xff",
     };
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // keep track of the worst case log size
@@ -6514,15 +6741,16 @@ 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_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_REG, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 if (k >= j) {
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
                 } else {
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
             }
-            lfsr_rbyd_get(&lfs, &rbyd, N-1, LFSR_TAG_REG, buffer, 4)
-                    => LFS_ERR_NOENT;
+            lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_REG,
+                    &data) => LFS_ERR_NOENT;
 
             // try recreating the rid to make sure things still work
             printf("--- create: %d ---\n", j);
@@ -6534,12 +6762,12 @@ code = '''
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 6)
-                            => 6;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_REG, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
                 } else {
-                    lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 6)
-                            => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_REG, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
             }
@@ -6601,6 +6829,7 @@ code = '''
         "\xee\xee\xee\xee\xee\xee",
         "\xff\xff\xff\xff\xff\xff",
     };
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // keep track of the worst case log size
@@ -6676,7 +6905,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_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_REG, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 if (k >= j) {
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
                 } else {
@@ -6684,8 +6914,9 @@ code = '''
                 }
 
                 for (unsigned u = 0; u < M; u++) {
-                    lfsr_rbyd_get(&lfs, &rbyd,
-                            k, LFSR_TAG_UATTR(u+1), buffer, 4) => 2;
+                    lfsr_rbyd_lookup(&lfs, &rbyd,
+                            k, LFSR_TAG_UATTR(u+1), &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                     if (k >= j) {
                         assert(memcmp(buffer, names[(k+1) % 6], 2) == 0);
                     } else {
@@ -6693,10 +6924,10 @@ code = '''
                     }
                 }
             }
-            lfsr_rbyd_get(&lfs, &rbyd, N-1, LFSR_TAG_REG, buffer, 4)
-                    => LFS_ERR_NOENT;
-            lfsr_rbyd_get(&lfs, &rbyd, N-1, LFSR_TAG_UATTR(1), buffer, 4)
-                    => LFS_ERR_NOENT;
+            lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_REG,
+                    &data) => LFS_ERR_NOENT;
+            lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_UATTR(1),
+                    &data) => LFS_ERR_NOENT;
 
             // try recreating the rid to make sure things still work
             printf("--- create: %d ---\n", j);
@@ -6713,25 +6944,25 @@ code = '''
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
-                    lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 6)
-                            => 6;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_REG, &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_get(&lfs, &rbyd,
-                                k, LFSR_TAG_UATTR(u+1), buffer, 6)
-                                => 3;
+                        lfsr_rbyd_lookup(&lfs, &rbyd,
+                                k, LFSR_TAG_UATTR(u+1), &data) => 0;
+                        lfsr_data_read(&lfs, &data, buffer, 6) => 3;
                         assert(memcmp(buffer, names[k % 6], 3) == 0);
                     }
                 } else {
-                    lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 6)
-                            => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_REG, &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_get(&lfs, &rbyd,
-                                k, LFSR_TAG_UATTR(u+1), buffer, 6)
-                                => 2;
+                        lfsr_rbyd_lookup(&lfs, &rbyd,
+                                k, LFSR_TAG_UATTR(u+1), &data) => 0;
+                        lfsr_data_read(&lfs, &data, buffer, 6) => 2;
                         assert(memcmp(buffer, names[k % 6], 2) == 0);
                     }
                 }
@@ -6796,6 +7027,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -6871,7 +7103,8 @@ code = '''
                 assert(rid_ == k);
                 assert(lfsr_data_size(&data_) == 4);
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 if (k >= j) {
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
                 } else {
@@ -6922,6 +7155,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -7003,7 +7237,8 @@ code = '''
                 assert(rid_ == k);
                 assert(lfsr_data_size(&data_) == 4);
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 if (k >= j) {
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
                 } else {
@@ -7017,7 +7252,8 @@ code = '''
                     assert(rid_ == k);
                     assert(lfsr_data_size(&data_) == 2);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 4) => 2;
                     if (k >= j) {
                         assert(memcmp(buffer, names[(k+1) % 6], 2) == 0);
                     } else {
@@ -7051,7 +7287,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
-    uint8_t buffer[4];
+    lfsr_data_t data;
 
     // create and delete one rid
     rbyd = init_rbyd;
@@ -7062,13 +7298,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // create and delete two ids
     rbyd = init_rbyd;
@@ -7081,13 +7317,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // create and delete two ids in the other order
     rbyd = init_rbyd;
@@ -7101,13 +7337,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // create and delete three ids
     rbyd = init_rbyd;
@@ -7122,13 +7358,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // create and delete three ids in the other order
     rbyd = init_rbyd;
@@ -7145,13 +7381,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
 '''
 
@@ -7169,7 +7405,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
-    uint8_t buffer[4];
+    lfsr_data_t data;
 
     // create and delete one rid
     rbyd = init_rbyd;
@@ -7181,13 +7417,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // create and delete two ids
     rbyd = init_rbyd;
@@ -7202,13 +7438,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // create and delete two ids in the other order
     rbyd = init_rbyd;
@@ -7224,13 +7460,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // create and delete three ids
     rbyd = init_rbyd;
@@ -7248,13 +7484,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     // create and delete three ids in the other order
     rbyd = init_rbyd;
@@ -7274,13 +7510,13 @@ code = '''
             LFSR_ATTR(RM, -1, NULL()))) => 0;
 
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
-    lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
-            => LFS_ERR_NOENT;
+    lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
+            &data) => LFS_ERR_NOENT;
 '''
 
 # NOTE if we separate physical/logical block sizes we may be able to
@@ -7313,6 +7549,7 @@ code = '''
         "\xee\xee\xee\xee",
         "\xff\xff\xff\xff",
     };
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // keep track of the worst case log size
@@ -7382,9 +7619,9 @@ code = '''
         // check that all tags are now removed
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 0);
-        lfsr_rbyd_get(&lfs, &rbyd,
-                LFSR_TAG_REG, 0, buffer, 4)
-                => LFS_ERR_NOENT;
+        lfsr_rbyd_lookup(&lfs, &rbyd,
+                LFSR_TAG_REG, 0,
+                &data) => LFS_ERR_NOENT;
 
         // try resuming from all tags being removed
         lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
@@ -7394,13 +7631,13 @@ code = '''
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 1);
-        lfsr_rbyd_get(&lfs, &rbyd,
-                0, LFSR_TAG_REG, buffer, 6)
-                => 6;
+        lfsr_rbyd_lookup(&lfs, &rbyd,
+                0, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 6) => 6;
         assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0);
-        lfsr_rbyd_get(&lfs, &rbyd,
-                1, LFSR_TAG_REG, buffer, 6)
-                => LFS_ERR_NOENT;
+        lfsr_rbyd_lookup(&lfs, &rbyd,
+                1, LFSR_TAG_REG,
+                &data) => LFS_ERR_NOENT;
 
         // keep track of the worst size
         if (rbyd.eoff > worst_size) {
@@ -7458,6 +7695,7 @@ code = '''
         "\xee\xee\xee\xee",
         "\xff\xff\xff\xff",
     };
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // keep track of the worst case log size
@@ -7532,9 +7770,9 @@ code = '''
         // check that all tags are now removed
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 0);
-        lfsr_rbyd_get(&lfs, &rbyd,
-                0, LFSR_TAG_REG, buffer, 4)
-                => LFS_ERR_NOENT;
+        lfsr_rbyd_lookup(&lfs, &rbyd,
+                0, LFSR_TAG_REG,
+                &data) => LFS_ERR_NOENT;
 
         // try resuming from all tags being removed
         lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
@@ -7548,22 +7786,22 @@ code = '''
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 1);
-        lfsr_rbyd_get(&lfs, &rbyd,
-                0, LFSR_TAG_REG, buffer, 6)
-                => 6;
+        lfsr_rbyd_lookup(&lfs, &rbyd,
+                0, LFSR_TAG_REG, &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_get(&lfs, &rbyd,
-                    0, LFSR_TAG_UATTR(u+1), buffer, 6)
-                    => 3;
+            lfsr_rbyd_lookup(&lfs, &rbyd,
+                    0, LFSR_TAG_UATTR(u+1), &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 6) => 3;
             assert(memcmp(buffer, "\xaa\xaa\xaa", 3) == 0);
         }
-        lfsr_rbyd_get(&lfs, &rbyd,
-                1, LFSR_TAG_REG, buffer, 6)
-                => LFS_ERR_NOENT;
-        lfsr_rbyd_get(&lfs, &rbyd,
-                1, LFSR_TAG_UATTR(1), buffer, 6)
-                => LFS_ERR_NOENT;
+        lfsr_rbyd_lookup(&lfs, &rbyd,
+                1, LFSR_TAG_REG,
+                &data) => LFS_ERR_NOENT;
+        lfsr_rbyd_lookup(&lfs, &rbyd,
+                1, LFSR_TAG_UATTR(1),
+                &data) => LFS_ERR_NOENT;
 
         // keep track of the worst size
         if (rbyd.eoff > worst_size) {
@@ -7610,6 +7848,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     printf("perm: [");
@@ -7676,9 +7915,10 @@ code = '''
     printf("]\n");
     printf("rbyd: [");
     for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)rbyd.weight; rid++) {
-        lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd,
-                rid, LFSR_TAG_REG, buffer, 4);
-        if (size >= 0) {
+        int err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_REG,
+                &data);
+        if (!err) {
+            lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
             printf("%.*s", size, buffer);
         } else {
             printf("?");
@@ -7691,7 +7931,8 @@ code = '''
 
     assert(count == rbyd.weight);
     for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) {
-        lfsr_rbyd_get(&lfs, &rbyd, rid, LFSR_TAG_REG, buffer, 4) => 1;
+        lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 4) => 1;
         assert(memcmp(&sim[rid], buffer, 1) == 0);
     }
 
@@ -8073,6 +8314,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -8121,7 +8363,8 @@ code = '''
             assert(weight_ == W);
             assert(lfsr_data_size(&data_) == 4);
 
-            lfsr_rbyd_get(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
     }
@@ -8160,6 +8403,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -8211,7 +8455,8 @@ code = '''
             assert(weight_ == W);
             assert(lfsr_data_size(&data_) == 4);
 
-            lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
         lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -9174,6 +9419,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -9246,7 +9492,8 @@ code = '''
             assert(weight_ == 0);
             assert(lfsr_data_size(&data_) == 2);
 
-            lfsr_rbyd_get(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
         }
     }
@@ -9285,6 +9532,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -9348,7 +9596,8 @@ code = '''
             assert(weight_ == W);
             assert(lfsr_data_size(&data_) == 4);
 
-            lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+            lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+            lfsr_data_read(&lfs, &data, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
 
             lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
@@ -9406,6 +9655,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -9494,7 +9744,8 @@ code = '''
                     assert(lfsr_data_size(&data_) == 4);
                 }
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
             }
         }
@@ -9535,6 +9786,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // test all permutations of a given size
@@ -9609,7 +9861,8 @@ code = '''
                     assert(weight_ == W+D);
                     assert(lfsr_data_size(&data_) == 6);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
                 } else if (k > j) {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG,
@@ -9619,7 +9872,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -9629,7 +9883,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
             }
@@ -9673,6 +9928,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // test all permutations of a given size
@@ -9748,7 +10004,8 @@ code = '''
                     assert(weight_ == W+D);
                     assert(lfsr_data_size(&data_) == 6);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
 
                     lfsr_rbyd_lookupnext(&lfs, &rbyd,
@@ -9759,7 +10016,8 @@ code = '''
                     assert(weight_ == 0);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else if (k > j) {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd,
@@ -9770,7 +10028,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd,
@@ -9781,7 +10040,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
             }
@@ -9823,6 +10083,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -9911,7 +10172,8 @@ code = '''
                     assert(lfsr_data_size(&data_) == 4);
                 }
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
             }
         }
@@ -9952,6 +10214,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // test all permutations of a given size
@@ -10026,7 +10289,8 @@ code = '''
                     assert(weight_ == W-D);
                     assert(lfsr_data_size(&data_) == 6);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
                 } else if (k > j) {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG,
@@ -10036,7 +10300,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -10046,7 +10311,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
             }
@@ -10090,6 +10356,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // test all permutations of a given size
@@ -10165,7 +10432,8 @@ code = '''
                     assert(weight_ == W-D);
                     assert(lfsr_data_size(&data_) == 6);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
 
                     lfsr_rbyd_lookupnext(&lfs, &rbyd,
@@ -10176,7 +10444,8 @@ code = '''
                     assert(weight_ == 0);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else if (k > j) {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd,
@@ -10187,7 +10456,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 } else {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd,
@@ -10198,7 +10468,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
             }
@@ -10239,6 +10510,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[6];
 
     // test all permutations of a given size
@@ -10312,7 +10584,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                     assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
                 } else {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -10322,7 +10595,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
             }
@@ -10344,7 +10618,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 6);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 6;
                     assert(memcmp(buffer, names[k % 6], 6) == 0);
                 } else {
                     lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -10354,7 +10629,8 @@ code = '''
                     assert(weight_ == W);
                     assert(lfsr_data_size(&data_) == 4);
 
-                    lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                    lfsr_data_read(&lfs, &data, buffer, 6) => 4;
                     assert(memcmp(buffer, names[k % 6], 4) == 0);
                 }
             }
@@ -10395,6 +10671,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     // test all permutations of a given size
@@ -10469,7 +10746,8 @@ code = '''
                 assert(weight_ == W);
                 assert(lfsr_data_size(&data_) == 4);
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
                 if (k == j) {
@@ -10499,12 +10777,13 @@ code = '''
                 assert(weight_ == W);
                 assert(lfsr_data_size(&data_) == 4);
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
                 if (k == j) {
-                    lfsr_rbyd_get(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(1),
-                            buffer, 4) => LFS_ERR_NOENT;
+                    lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(1),
+                            &data) => LFS_ERR_NOENT;
                 }
             }
 
@@ -10525,7 +10804,8 @@ code = '''
                 assert(weight_ == W);
                 assert(lfsr_data_size(&data_) == 4);
 
-                lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4;
+                lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+                lfsr_data_read(&lfs, &data, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
 
                 if (k == j) {
@@ -10564,6 +10844,7 @@ code = '''
         .weight = 0,
     };
     lfsr_rbyd_t rbyd;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     printf("perm: [");
@@ -10664,17 +10945,19 @@ code = '''
     printf("]\n");
     printf("rbyd: [");
     for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)rbyd.weight; rid++) {
-        lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd,
-                rid, LFSR_TAG_REG, buffer, 4);
-        if (size >= 0) {
+        int err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_REG,
+                &data);
+        if (!err) {
+            lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
             printf("%.*s", size, buffer);
         } else {
             printf("?");
         }
         for (uint8_t u = 0; u < M; u++) {
-            lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd,
-                    rid, LFSR_TAG_UATTR(u), buffer, 4);
-            if (size >= 0) {
+            err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_UATTR(u),
+                    &data);
+            if (!err) {
+                lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
                 printf("%.*s", size, buffer);
             } else {
                 printf("_");
@@ -10688,7 +10971,8 @@ code = '''
 
     assert(count == rbyd.weight);
     for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) {
-        lfsr_rbyd_get(&lfs, &rbyd, rid, LFSR_TAG_REG, buffer, 4) => 1;
+        lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_REG, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 4) => 1;
         assert(memcmp(&sim[rid*(M+1)], buffer, 1) == 0);
     }
 
@@ -10719,6 +11003,7 @@ code = '''
     lfs_ssize_t rid_;
     lfs_size_t weight_;
     lfsr_data_t data_;
+    lfsr_data_t data;
     uint8_t buffer[4];
 
     printf("perm: [");
@@ -10842,8 +11127,7 @@ code = '''
                 weighted_rid, LFSR_TAG_REG,
                 &rid_, &tag_, &weight_, &data_);
         if (!err) {
-            lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd,
-                    rid_, tag_, buffer, 4);
+            lfs_ssize_t size = lfsr_data_read(&lfs, &data_, buffer, 4);
             if (size >= 0) {
                 printf("%.*sw%d", size, buffer, weight_);
             } else {
@@ -10875,7 +11159,8 @@ code = '''
         lfsr_rbyd_lookupnext(&lfs, &rbyd,
                 weighted_rid, LFSR_TAG_REG,
                 &rid_, &tag_, &weight_, &data_) => 0;
-        lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 1;
+        lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, &data) => 0;
+        lfsr_data_read(&lfs, &data, buffer, 4) => 1;
         assert(memcmp(&sim[rid], buffer, 1) == 0);
     }