diff --git a/lfs.c b/lfs.c
index d78ebf1d..3d973f44 100644
--- a/lfs.c
+++ b/lfs.c
@@ -746,7 +746,7 @@ static inline lfs_off_t lfsr_data_off(lfsr_data_t data) {
 }
 
 static inline lfs_size_t lfsr_data_len(lfsr_data_t data) {
-    return data.len < 0 ? -data.len : data.len;
+    return lfs_abs32(data.len);
 }
 
 
@@ -1165,10 +1165,15 @@ static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) {
 
 /// Red-black-yellow Dhara tree operations ///
 
+// helper functions
+static bool lfsr_rbyd_isfetched(const lfsr_rbyd_t *rbyd) {
+    return !(rbyd->off == 0 && rbyd->trunk > 0);
+}
+
 
 // allocate an rbyd block
 static int lfsr_rbyd_alloc(lfs_t *lfs, lfsr_rbyd_t *rbyd, uint32_t rev) {
-    *rbyd = (lfsr_rbyd_t){.rev=rev, .off=0};
+    *rbyd = (lfsr_rbyd_t){.rev=rev, .off=0, .trunk=0};
     int err = lfs_alloc(lfs, &rbyd->block);
     if (err) {
         return err;
@@ -1280,7 +1285,7 @@ static lfs_ssize_t lfsr_rbyd_readtag(lfs_t *lfs,
 }
 
 static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
-        lfs_block_t block, lfs_size_t limit,
+        lfs_block_t block, lfs_size_t trunk,
         lfsr_find_t *find) {
     // clear any previous state in our find
     if (find) {
@@ -1293,7 +1298,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     // read the revision count and get the crc started
     uint32_t rev;
     int err = lfs_bd_read(lfs,
-            NULL, &lfs->rcache, limit,
+            NULL, &lfs->rcache, lfs->cfg->block_size,
             block, 0, &rev, sizeof(uint32_t));
     if (err) {
         return err;
@@ -1309,7 +1314,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
 
     // temporary state until we validate a crc
     lfs_off_t off = sizeof(uint32_t);
-    lfs_off_t trunk = 0;
+    lfs_off_t trunk_ = 0;
     bool wastrunk = false;
     lfs_size_t lower = 0;
     lfs_size_t upper = 0;
@@ -1321,77 +1326,32 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     bool maybeerased = false;
 
     // scan tags, checking valid bits, crcs, etc
-    while (off < limit) {
+    while (off < lfs->cfg->block_size && (!trunk || rbyd->off <= trunk)) {
         lfsr_tag_t tag;
         lfs_size_t w;
         lfs_size_t size;
-        lfs_ssize_t delta = lfsr_rbyd_readtag(lfs,
-                NULL, &lfs->rcache, limit-off,
+        lfs_ssize_t d = lfsr_rbyd_readtag(lfs,
+                NULL, &lfs->rcache, lfs->cfg->block_size-off,
                 block, off, &tag, &w, &size, &crc);
-        if (delta < 0) {
-            if (delta == LFS_ERR_INVAL || delta == LFS_ERR_CORRUPT) {
-                maybeerased = maybeerased && delta == LFS_ERR_INVAL;
+        if (d < 0) {
+            if (d == LFS_ERR_INVAL || d == LFS_ERR_CORRUPT) {
+                maybeerased = maybeerased && d == LFS_ERR_INVAL;
                 break;
             }
-            return delta;
-        }
-
-        // found trunk of tree?
-        if (!wastrunk && lfsr_tag_istrunk(tag)) {
-            trunk = off;
-            lower = 0;
-            upper = 0;
-        }
-        wastrunk = lfsr_tag_isalt(tag);
-        off += delta;
-
-        // derive the new weight of the tree from alt pointers
-        //
-        // NOTE we can't check for overflow/underflow here because we
-        // may be overeagerly parsing an invalid commit, it's ok for
-        // this to overflow/underflow as long as we throw it out later
-        // on a bad crc
-        if (lfsr_tag_isalt(tag)) {
-            if (lfsr_tag_isgt(tag)) {
-                upper += w;
-            } else {
-                lower += w;
-            }
-
-        } else if (lfsr_tag_istrunk(tag)) {
-            // note we need to include our id's weight in our weight
-            // calculation, but only when our id is included in the tree
-            lfs_ssize_t delta = (lower+upper+w) - weight;
-            weight = lower+upper+ w;
-
-            // adjust any pending finds
-            if (find && find->predicted_id >= (lfs_ssize_t)lower) {
-                // pending find removed?
-                if (delta < 0
-                        && find->predicted_id < (lfs_ssize_t)lower + -delta) {
-                    find->predicted_tag = 0;
-                    find->predicted_id = lower-1; // TODO is this correct for insertion behavior?
-                } else {
-                    find->predicted_id += delta;
-                }
-            }
-        }
-
-        // we mostly just skip non-data tags here
-        if (lfsr_tag_isalt(tag)) {
-            continue;
+            return d;
         }
+        off += d;
 
         // tag goes out of range?
-        if (off + size > limit) {
+        if (!lfsr_tag_isalt(tag) && off + size > lfs->cfg->block_size) {
             break;
         }
 
         // not an end-of-commit crc
-        if (lfsr_tag_suptype(tag) != LFSR_TAG_CRC) {
-            // crc the entry first, hopefully leaving it in the cache
+        if (!lfsr_tag_isalt(tag) && lfsr_tag_suptype(tag) != LFSR_TAG_CRC) {
+            // crc the entry, hopefully leaving it in the cache
             err = lfs_bd_crc32c(lfs,
-                    NULL, &lfs->rcache, limit-off,
+                    NULL, &lfs->rcache, lfs->cfg->block_size-off,
                     block, off, size, &crc);
             if (err) {
                 if (err == LFS_ERR_CORRUPT) {
@@ -1404,7 +1364,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
             if (tag == LFSR_TAG_FCRC) {
                 uint8_t fbuf[LFSR_FCRC_DSIZE];
                 err = lfs_bd_read(lfs,
-                        NULL, &lfs->rcache, limit-off,
+                        NULL, &lfs->rcache, lfs->cfg->block_size-off,
                         block, off, fbuf, lfs_min(size, LFSR_FCRC_DSIZE));
                 if (err) {
                     if (err == LFS_ERR_CORRUPT) {
@@ -1413,49 +1373,18 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
                     return err;
                 }
 
-                lfs_ssize_t delta = lfsr_fcrc_fromdisk(&fcrc, fbuf);
-                if (delta < 0) {
-                    return delta;
+                lfs_ssize_t d = lfsr_fcrc_fromdisk(&fcrc, fbuf);
+                if (d < 0) {
+                    return d;
                 }
                 hasfcrc = true;
             }
 
-            // found our find?
-            if (find && lfsr_tag_suptype(tag) == LFSR_TAG_NAME) {
-                // compare with disk
-                lfs_size_t diff = lfs_min(size, find->name_len);
-                int cmp = lfs_bd_cmp(lfs,
-                        NULL, &lfs->rcache, diff,
-                        block, off, find->name, diff);
-                if (cmp < 0) {
-                    return cmp;
-                }
-
-                if (cmp == LFS_CMP_EQ) {
-                    if (size < find->name_len) {
-                        cmp = LFS_CMP_LT;
-                    } else if (size > find->name_len) {
-                        cmp = LFS_CMP_GT;
-                    }
-                }
-
-                // found match?
-                lfs_ssize_t id = lower+w-1;
-                if (cmp == LFS_CMP_EQ) {
-                    find->predicted_tag = tag;
-                    find->predicted_id = id;
-                // didn't find a match, but found a better insertion point
-                } else if (cmp == LFS_CMP_LT && id > find->predicted_id) {
-                    find->predicted_tag = 0;
-                    find->predicted_id = id;
-                }
-            }
-
         // is an end-of-commit crc
-        } else {
+        } else if (!lfsr_tag_isalt(tag)) {
             uint32_t crc_ = 0;
             err = lfs_bd_read(lfs,
-                    NULL, &lfs->rcache, limit-off,
+                    NULL, &lfs->rcache, lfs->cfg->block_size-off,
                     block, off, &crc_, sizeof(uint32_t));
             if (err) {
                 if (err == LFS_ERR_CORRUPT) {
@@ -1483,7 +1412,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
             // save what we've found so far
             rbyd->off = off + size;
             rbyd->crc = crc;
-            rbyd->trunk = trunk;
+            rbyd->trunk = trunk_;
             rbyd->weight = weight;
 
             if (find) {
@@ -1492,10 +1421,90 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
             }
         }
 
-        off += size;
+        // found a trunk of a tree?
+        if (lfsr_tag_istrunk(tag) && (!trunk || trunk >= off-d || wastrunk)) {
+            if (!wastrunk) {
+                // save trunk entry point
+                trunk_ = off-d;
+                // reset weights
+                lower = 0;
+                upper = 0;
+                wastrunk = true;
+            }
+
+            // derive the new weight of the tree from alt pointers
+            //
+            // NOTE we can't check for overflow/underflow here because we
+            // may be overeagerly parsing an invalid commit, it's ok for
+            // this to overflow/underflow as long as we throw it out later
+            // on a bad crc
+            if (lfsr_tag_isalt(tag)) {
+                if (lfsr_tag_isgt(tag)) {
+                    upper += w;
+                } else {
+                    lower += w;
+                }
+
+            } else {
+                lfs_ssize_t delta = (lower+upper+w) - weight;
+                weight = lower+upper+w;
+
+                // adjust any pending finds
+                if (find && find->predicted_id >= (lfs_ssize_t)lower) {
+                    // pending find removed?
+                    if (delta < 0
+                            && find->predicted_id
+                                < (lfs_ssize_t)lower + -delta) {
+                        find->predicted_tag = 0;
+                        // TODO is this correct for insertion behavior?
+                        find->predicted_id = lower-1;
+                    } else {
+                        find->predicted_id += delta;
+                    }
+                }
+
+                // found our find?
+                if (find && lfsr_tag_suptype(tag) == LFSR_TAG_NAME) {
+                    // compare with disk
+                    lfs_size_t d = lfs_min(size, find->name_len);
+                    int cmp = lfs_bd_cmp(lfs,
+                            NULL, &lfs->rcache, d,
+                            block, off, find->name, d);
+                    if (cmp < 0) {
+                        return cmp;
+                    }
+
+                    if (cmp == LFS_CMP_EQ) {
+                        if (size < find->name_len) {
+                            cmp = LFS_CMP_LT;
+                        } else if (size > find->name_len) {
+                            cmp = LFS_CMP_GT;
+                        }
+                    }
+
+                    // found match?
+                    lfs_ssize_t id = lower+w-1;
+                    if (cmp == LFS_CMP_EQ) {
+                        find->predicted_tag = tag;
+                        find->predicted_id = id;
+                    // didn't find a match, but found a better insertion point
+                    } else if (cmp == LFS_CMP_LT && id > find->predicted_id) {
+                        find->predicted_tag = 0;
+                        find->predicted_id = id;
+                    }
+                }
+
+                // any non-alt terminates the current trunk
+                wastrunk = false;
+            }
+        }
+
+        if (!lfsr_tag_isalt(tag)) {
+            off += size;
+        }
     }
 
-    // no valid commits at all?
+    // no valid commits?
     if (rbyd->off == 0) {
         return LFS_ERR_CORRUPT;
     }
@@ -1506,11 +1515,11 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
         // check for an fcrc matching the next prog's erased state, if
         // this failed most likely a previous prog was interrupted, we
         // need a new erase
-        //
-        // note this does go beyond limit
         uint32_t fcrc_ = 0;
         int err = lfs_bd_crc32c(lfs,
-                NULL, &lfs->rcache, limit-lfs_min(off, limit),
+                // TODO is this the correct hint?
+                NULL, &lfs->rcache, lfs->cfg->block_size
+                    - lfs_min(off, lfs->cfg->block_size),
                 rbyd->block, rbyd->off, fcrc.size, &fcrc_);
         if (err && err != LFS_ERR_CORRUPT) {
             return err;
@@ -1928,6 +1937,8 @@ static void lfsr_rbyd_p_red(
 static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd,
         lfs_ssize_t id, lfsr_tag_t tag, lfs_ssize_t delta,
         lfsr_data_t data) {
+    // must fetch before mutating!
+    LFS_ASSERT(lfsr_rbyd_isfetched(rbyd));
     // never write zero tags to disk, use unr if tag contains no data
     LFS_ASSERT(tag != 0);
 
@@ -2024,8 +2035,8 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     lfsr_tag_t other_lower_tag = 0;
     lfsr_tag_t other_upper_tag = 0;
 
-    // go ahead and update the rbyd's weight, note that lfsr_rbyd_commit
-    // will through out this copy of the rbyd if an error occurs
+    // go ahead and update the rbyd's weight, if an error occurs our
+    // rbyd is no longer usable anyways
     LFS_ASSERT(delta >= -(lfs_ssize_t)rbyd->weight);
     rbyd->weight += delta;
 
@@ -2392,6 +2403,9 @@ failed:;
 
 static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd,
         const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+    // must fetch before mutating!
+    LFS_ASSERT(lfsr_rbyd_isfetched(rbyd));
+
     // we can't do anything if we're not erased
     int err;
     if (rbyd->off >= lfs->cfg->block_size) {
@@ -2568,97 +2582,202 @@ failed:;
 
 /// Rbyd b-tree operations ///
 
-// TODO this is a weird null, move weight out of inlined?
+
+// convenience operations
+
 #define LFSR_BTREE_NULL ((lfsr_btree_t){.weight=0})
 
-// B-tree on-disk encoding
+static bool lfsr_btree_isnull(const lfsr_btree_t *btree) {
+    return btree->weight == 0;
+}
 
-// 2 leb128 => 10 bytes (worst case)
-#define LFSR_BRANCH_DSIZE 10
+static bool lfsr_btree_isinlined(const lfsr_btree_t *btree) {
+    return btree->weight < 0;
+}
+
+static bool lfsr_btree_istree(const lfsr_btree_t *btree) {
+    return btree->weight > 0;
+}
+
+static lfs_size_t lfsr_btree_weight(const lfsr_btree_t *btree) {
+    return lfs_abs32(btree->weight);
+}
+
+
+// branch on-disk encoding
+
+//// 2 leb128 => 10 bytes (worst case)
+//#define LFSR_BRANCH_DSIZE 10
+
+// 2 leb128 + 1 crc32c => 14 bytes (worst case)
+#define LFSR_BRANCH_DSIZE (5+5+4)
 
 static lfs_ssize_t lfsr_branch_todisk(
-        const lfsr_branch_t *branch,
+        const lfsr_rbyd_t *branch,
         uint8_t buf[static LFSR_BRANCH_DSIZE]) {
-    lfs_ssize_t delta = 0;
-    lfs_ssize_t delta_ = lfs_toleb128(branch->block, &buf[delta], 5);
-    if (delta_ < 0) {
-        return delta_;
+    lfs_ssize_t d = 0;
+    lfs_ssize_t d_ = lfs_toleb128(branch->trunk, &buf[d], 5);
+    if (d_ < 0) {
+        return d_;
     }
-    delta += delta_;
+    d += d_;
 
-    delta_ = lfs_toleb128(branch->limit, &buf[delta], 5);
-    if (delta_ < 0) {
-        return delta_;
+    d_ = lfs_toleb128(branch->block, &buf[d], 5);
+    if (d_ < 0) {
+        return d_;
     }
-    delta += delta_;
+    d += d_;
 
-    return delta;
+    lfs_tole32_(branch->crc, &buf[d]);
+    d += 4;
+
+    return d;
 }
 
 static lfs_ssize_t lfsr_branch_fromdisk(
-        lfsr_branch_t *branch,
+        lfsr_rbyd_t *branch,
+        lfs_size_t weight,
         const uint8_t buf[static LFSR_BRANCH_DSIZE]) {
-    lfs_ssize_t delta = 0;
-    lfs_ssize_t delta_ = lfs_fromleb128(&branch->block, &buf[delta], 5);
-    if (delta_ < 0) {
-        return delta_;
-    }
-    delta += delta_;
+    // we usually inherit weight from the parent
+    branch->weight = weight;
+    // setting off to 0 here will trigger asserts if we try to append
+    // without fetching first
+    branch->off = 0;
 
-    delta_ = lfs_fromleb128(&branch->limit, &buf[delta], 5);
-    if (delta_ < 0) {
-        return delta_;
+    lfs_ssize_t d = 0;
+    lfs_ssize_t d_ = lfs_fromleb128(&branch->trunk, &buf[d], 5);
+    if (d_ < 0) {
+        return d_;
     }
-    delta += delta_;
+    d += d_;
 
-    return delta;
+    d_ = lfs_fromleb128(&branch->block, &buf[d], 5);
+    if (d_ < 0) {
+        return d_;
+    }
+    d += d_;
+
+    branch->crc = lfs_fromle32_(&buf[d]);
+    d += 4;
+
+    return 4;
 }
 
+//static lfs_ssize_t lfsr_branch_todisk(
+//        const lfsr_branch_t *branch,
+//        uint8_t buf[static LFSR_BRANCH_DSIZE]) {
+//    lfs_ssize_t delta = 0;
+//    lfs_ssize_t delta_ = lfs_toleb128(branch->block, &buf[delta], 5);
+//    if (delta_ < 0) {
+//        return delta_;
+//    }
+//    delta += delta_;
+//
+//    delta_ = lfs_toleb128(branch->limit, &buf[delta], 5);
+//    if (delta_ < 0) {
+//        return delta_;
+//    }
+//    delta += delta_;
+//
+//    return delta;
+//}
+//
+//static lfs_ssize_t lfsr_branch_fromdisk(
+//        lfsr_branch_t *branch,
+//        const uint8_t buf[static LFSR_BRANCH_DSIZE]) {
+//    lfs_ssize_t delta = 0;
+//    lfs_ssize_t delta_ = lfs_fromleb128(&branch->block, &buf[delta], 5);
+//    if (delta_ < 0) {
+//        return delta_;
+//    }
+//    delta += delta_;
+//
+//    delta_ = lfs_fromleb128(&branch->limit, &buf[delta], 5);
+//    if (delta_ < 0) {
+//        return delta_;
+//    }
+//    delta += delta_;
+//
+//    return delta;
+//}
+
 
 // B-tree operations
 
 static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
-        const lfsr_btree_t *btree, lfs_size_t id,
-        lfs_size_t *id_, lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_,
+        const lfsr_btree_t *btree, lfs_size_t bid,
+        lfs_size_t *bid_, lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_,
         lfsr_tag_t *tag_, lfs_size_t *weight_,
-        void *buffer, lfs_size_t size) {
+        void *buffer, lfs_size_t size, bool validate) {
     // in range?
-    if (id >= btree->weight) {
+    if (bid >= lfsr_btree_weight(btree)) {
         return LFS_ERR_NOENT;
     }
 
     // inlined?
-    if (btree->tag) {
+    if (lfsr_btree_isinlined(btree)) {
         // TODO how many of these should be conditional?
-        if (id_) {
-            *id_ = btree->weight-1;
+        if (bid_) {
+            *bid_ = lfsr_btree_weight(btree)-1;
         }
         // TODO need rid here?
         if (rid_) {
             *rid_ = -1;
         }
         if (tag_) {
-            *tag_ = btree->tag;
+            *tag_ = btree->inlined.tag;
         }
         if (weight_) {
-            *weight_ = btree->weight;
+            *weight_ = lfsr_btree_weight(btree);
         }
 
-        memcpy(buffer, btree->u.inlined.buf,
-                lfs_min(size, btree->u.inlined.size));
-        return btree->u.inlined.size;
+        memcpy(buffer, btree->inlined.buf,
+                lfs_min(size, btree->inlined.len));
+        return btree->inlined.len;
     }
 
-    // descend down the btree looking for our id
-    lfsr_rbyd_t rbyd;
-    lfs_ssize_t rid = id;
-    lfsr_branch_t branch = btree->u.trunk;
+    // a this point we must be a tree
+    LFS_ASSERT(lfsr_btree_istree(btree));
+
+    // descend down the btree looking for our bid
+    lfsr_rbyd_t branch = btree->root;
+    lfs_ssize_t rid = bid;
     while (true) {
-        // fetch each block, this is the main cost of lookup with each fetch
-        // needing O(m), and isn't really avoidable
-        int err = lfsr_rbyd_fetch(lfs, &rbyd, branch.block, branch.limit, NULL);
-        if (err) {
-            return err;
+        // if we're validating during our lookup, we need to fetch each branch,
+        // otherwise we can get away with assuming our stored block+trunk is
+        // correct
+        if (validate) {
+            lfsr_rbyd_t branch_;
+            int err = lfsr_rbyd_fetch(lfs, &branch_,
+                    branch.block, branch.trunk, NULL);
+            if (err) {
+                if (err == LFS_ERR_CORRUPT) {
+                    LFS_ERROR("Corrupted rbyd found during btree lookup "
+                            "(rbyd=0x%"PRIx32".%"PRIx32", "
+                            "0x%08"PRIx32" != 0x%08"PRIx32")",
+                            branch.block, branch.trunk,
+                            branch_.crc, branch.crc);
+                }
+                return err;
+            }
+
+            // test that our branch's crc matches what's expected
+            //
+            // it should be noted it's very unlikely for this to be hit without
+            // the above fetch failing since it includes both an internal
+            // crc check and trunk check
+            if (branch_.crc != branch.crc) {
+                LFS_ERROR("Corrupted rbyd found during btree lookup "
+                        "(rbyd=0x%"PRIx32".%"PRIx32", "
+                        "0x%08"PRIx32" != 0x%08"PRIx32")",
+                        branch.block, branch.trunk,
+                        branch_.crc, branch.crc);
+                return LFS_ERR_CORRUPT;
+            }
+
+            LFS_ASSERT(branch_.trunk == branch.trunk);
+            LFS_ASSERT(branch_.weight == branch.weight);
+            branch = branch_;
         }
 
         // each branch is a pair of optional name + on-disk structure
@@ -2667,7 +2786,7 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
         lfs_size_t weight__;
         lfs_off_t off_;
         lfs_size_t size_;
-        err = lfsr_rbyd_lookup(lfs, &rbyd, rid, 0,
+        int err = lfsr_rbyd_lookup(lfs, &branch, rid, 0,
                 &rid__, &tag__, &weight__, &off_, &size_);
         if (err) {
             return err;
@@ -2675,7 +2794,7 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
 
         if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
             // TODO what if we don't find a struct? ENOENT?
-            err = lfsr_rbyd_lookup(lfs, &rbyd, rid__, LFSR_TAG_STRUCT,
+            err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_STRUCT,
                     NULL, &tag__, NULL, &off_, &size_);
             if (err) {
                 return err;
@@ -2689,27 +2808,27 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
 
             // fetch the next branch
             uint8_t buf[LFSR_BRANCH_DSIZE];
-            lfs_ssize_t delta = lfs_min(LFSR_BRANCH_DSIZE, size_);
+            lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, size_);
             err = lfs_bd_read(lfs,
-                    &lfs->pcache, &lfs->rcache, delta,
-                    rbyd.block, off_, buf, delta);
+                    &lfs->pcache, &lfs->rcache, d,
+                    branch.block, off_, buf, d);
             if (err) {
                 return err;
             }
 
-            delta = lfsr_branch_fromdisk(&branch, buf);
-            if (delta < 0) {
-                return delta;
+            d = lfsr_branch_fromdisk(&branch, weight__, buf);
+            if (d < 0) {
+                return d;
             }
 
-        // found our id
+        // found our bid
         } else {
             // TODO how many of these should be conditional?
-            if (id_) {
-                *id_ = id + (rid__ - rid);
+            if (bid_) {
+                *bid_ = bid + (rid__ - rid);
             }
             if (rbyd_) {
-                *rbyd_ = rbyd;
+                *rbyd_ = branch;
             }
             if (rid_) {
                 *rid_ = rid__;
@@ -2725,7 +2844,7 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
             lfs_ssize_t delta = lfs_min(size, size_);
             err = lfs_bd_read(lfs,
                     &lfs->pcache, &lfs->rcache, delta,
-                    rbyd.block, off_, buffer, delta);
+                    branch.block, off_, buffer, delta);
             if (err) {
                 return err;
             }
@@ -2737,35 +2856,27 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
 
 // TODO should lfsr_btree_lookup/lfsr_btree_parent be deduplicated?
 static int lfsr_btree_parent(lfs_t *lfs,
-        const lfsr_btree_t *btree, lfs_size_t id, const lfsr_rbyd_t *child,
+        const lfsr_btree_t *btree, lfs_size_t bid, const lfsr_rbyd_t *child,
         lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_) {
     // inlined? root?
-    if (id >= btree->weight
-            || btree->tag
-            || (btree->u.trunk.block == child->block
-                && btree->u.trunk.limit == child->off)) {
+    if (bid >= lfsr_btree_weight(btree)
+            || lfsr_btree_isinlined(btree)
+            || (btree->root.block == child->block
+                && btree->root.trunk == child->trunk)) {
         return LFS_ERR_NOENT;
     }
 
     // descend down the btree looking for our id
-    lfsr_rbyd_t rbyd;
-    lfs_ssize_t rid = id;
-    lfsr_branch_t branch = btree->u.trunk;
+    lfsr_rbyd_t branch = btree->root;
+    lfs_ssize_t rid = bid;
     while (true) {
-        // fetch each block, this is the main cost of traversal with each fetch
-        // needing O(m), and isn't really avoidable
-        int err = lfsr_rbyd_fetch(lfs, &rbyd, branch.block, branch.limit, NULL);
-        if (err) {
-            return err;
-        }
-
         // each branch is a pair of optional name + on-disk structure
         lfs_ssize_t rid__;
         lfsr_tag_t tag__;
         lfs_size_t weight__;
         lfs_off_t off_;
         lfs_size_t size_;
-        err = lfsr_rbyd_lookup(lfs, &rbyd, rid, 0,
+        int err = lfsr_rbyd_lookup(lfs, &branch, rid, 0,
                 &rid__, &tag__, &weight__, &off_, &size_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -2774,7 +2885,7 @@ static int lfsr_btree_parent(lfs_t *lfs,
 
         if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
             // TODO what if we don't find a struct? ENOENT?
-            err = lfsr_rbyd_lookup(lfs, &rbyd, rid__, LFSR_TAG_STRUCT,
+            err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_STRUCT,
                     NULL, &tag__, NULL, &off_, &size_);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -2792,30 +2903,33 @@ static int lfsr_btree_parent(lfs_t *lfs,
 
         // fetch the next branch
         uint8_t buf[LFSR_BRANCH_DSIZE];
-        lfs_ssize_t delta = lfs_min(LFSR_BRANCH_DSIZE, size_);
+        lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, size_);
         err = lfs_bd_read(lfs,
-                &lfs->pcache, &lfs->rcache, delta,
-                rbyd.block, off_, buf, delta);
+                &lfs->pcache, &lfs->rcache, d,
+                branch.block, off_, buf, d);
         if (err) {
             return err;
         }
 
-        delta = lfsr_branch_fromdisk(&branch, buf);
-        if (delta < 0) {
-            return delta;
+        lfsr_rbyd_t branch_;
+        d = lfsr_branch_fromdisk(&branch_, weight__, buf);
+        if (d < 0) {
+            return d;
         }
 
         // found our child?
-        if (branch.block == child->block && branch.limit == child->off) {
+        if (branch_.block == child->block && branch_.trunk == child->trunk) {
             // TODO how many of these should be conditional?
             if (rbyd_) {
-                *rbyd_ = rbyd;
+                *rbyd_ = branch;
             }
             if (rid_) {
                 *rid_ = rid__;
             }
             return 0;
         }
+
+        branch = branch_;
     }
 }
 
@@ -2823,55 +2937,79 @@ static int lfsr_btree_parent(lfs_t *lfs,
 static lfs_ssize_t lfsr_btree_get(lfs_t *lfs,
         const lfsr_btree_t *btree, lfs_size_t id,
         lfs_size_t *id_, lfsr_tag_t *tag_, lfs_size_t *weight_,
-        void *buffer, lfs_size_t size) {
-    // note we need an allocated rbyd in btree lookup
+        void *buffer, lfs_size_t size, bool validate) {
     return lfsr_btree_lookup(lfs, btree, id,
             id_, NULL, NULL, tag_, weight_,
-            buffer, size);
+            buffer, size, validate);
 }
 
 static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
         const lfsr_btree_t *btree, const char *name, lfs_size_t name_len,
-        lfs_size_t *id_,
+        lfs_size_t *bid_,
         lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_,
         lfsr_tag_t *tag_, lfs_size_t *weight_,
         void *buffer, lfs_size_t size) {
+    // an empty tree?
+    if (lfsr_btree_isnull(btree)) {
+        return LFS_ERR_NOENT;
+    }
+
     // inlined?
-    if (btree->tag) {
+    if (lfsr_btree_isinlined(btree)) {
         // TODO how many of these should be conditional?
-        if (id_) {
-            *id_ = btree->weight-1;
+        if (bid_) {
+            *bid_ = lfsr_btree_weight(btree)-1;
         }
         // TODO need rid here?
         if (rid_) {
             *rid_ = -1;
         }
         if (tag_) {
-            *tag_ = btree->tag;
+            *tag_ = btree->inlined.tag;
         }
         if (weight_) {
-            *weight_ = btree->weight;
+            *weight_ = lfsr_btree_weight(btree);
         }
 
-        memcpy(buffer, btree->u.inlined.buf,
-                lfs_min(size, btree->u.inlined.size));
-        return btree->u.inlined.size;
+        memcpy(buffer, btree->inlined.buf,
+                lfs_min(size, btree->inlined.len));
+        return btree->inlined.len;
     }
 
     // descend down the btree looking for our name
-    lfs_ssize_t id = 0;
-    lfsr_rbyd_t rbyd;
+    lfsr_rbyd_t branch = btree->root;
+    lfs_ssize_t bid = 0;
     lfsr_find_t find = {.name=name, .name_len=name_len};
-    lfsr_branch_t branch = btree->u.trunk;
     while (true) {
-        // fetch is the main cost of lookup, but we can exploit this to do our
-        // name search in the same pass
-        int err = lfsr_rbyd_fetch(lfs, &rbyd,
-                branch.block, branch.limit, &find);
+        // name lookup in our rbyds requires a linear search, so we might as
+        // well revalidate the rbyd with a fetch
+        lfsr_rbyd_t branch_;
+        int err = lfsr_rbyd_fetch(lfs, &branch_,
+                branch.block, branch.trunk, &find);
         if (err) {
+            if (err == LFS_ERR_CORRUPT) {
+                LFS_ERROR("Corrupted rbyd found during btree lookup "
+                        "(rbyd=0x%"PRIx32".%"PRIx32", "
+                        "0x%08"PRIx32" != 0x%08"PRIx32")",
+                        branch.block, branch.trunk,
+                        branch_.crc, branch.crc);
+            }
             return err;
         }
 
+        if (branch_.crc != branch.crc) {
+            LFS_ERROR("Corrupted rbyd found during btree lookup "
+                    "(rbyd=0x%"PRIx32".%"PRIx32", "
+                    "0x%08"PRIx32" != 0x%08"PRIx32")",
+                    branch.block, branch.trunk,
+                    branch_.crc, branch.crc);
+            return LFS_ERR_CORRUPT;
+        }
+
+        LFS_ASSERT(branch_.trunk == branch.trunk);
+        LFS_ASSERT(branch_.weight == branch.weight);
+        branch = branch_;
+
         // assume lowest id if no name found
         //
         // note this ignore any name attached to the lowest id, this is
@@ -2889,7 +3027,7 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
         lfs_size_t weight__;
         lfs_off_t off_;
         lfs_size_t size_;
-        err = lfsr_rbyd_lookup(lfs, &rbyd, find.found_id, 0,
+        err = lfsr_rbyd_lookup(lfs, &branch, find.found_id, 0,
                 &rid__, &tag__, &weight__, &off_, &size_);
         if (err) {
             return err;
@@ -2897,7 +3035,7 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
 
         if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
             // TODO what if we don't find a struct? ENOENT?
-            err = lfsr_rbyd_lookup(lfs, &rbyd, rid__, LFSR_TAG_STRUCT,
+            err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_STRUCT,
                     NULL, &tag__, NULL, &off_, &size_);
             if (err) {
                 return err;
@@ -2907,31 +3045,31 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
         // found another branch
         if (tag__ == LFSR_TAG_BRANCH) {
             // update our id
-            id += rid__-(weight__-1);
+            bid += rid__-(weight__-1);
 
             // fetch the next branch
             uint8_t buf[LFSR_BRANCH_DSIZE];
-            lfs_ssize_t delta = lfs_min(LFSR_BRANCH_DSIZE, size_);
+            lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, size_);
             err = lfs_bd_read(lfs,
-                    &lfs->pcache, &lfs->rcache, delta,
-                    rbyd.block, off_, buf, delta);
+                    &lfs->pcache, &lfs->rcache, d,
+                    branch.block, off_, buf, d);
             if (err) {
                 return err;
             }
 
-            delta = lfsr_branch_fromdisk(&branch, buf);
-            if (delta < 0) {
-                return delta;
+            d = lfsr_branch_fromdisk(&branch, weight__, buf);
+            if (d < 0) {
+                return d;
             }
 
         // found our id
         } else {
             // TODO how many of these should be conditional?
-            if (id_) {
-                *id_ = id + rid__;
+            if (bid_) {
+                *bid_ = bid + rid__;
             }
             if (rbyd_) {
-                *rbyd_ = rbyd;
+                *rbyd_ = branch;
             }
             if (rid_) {
                 *rid_ = rid__;
@@ -2947,7 +3085,7 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
             lfs_ssize_t delta = lfs_min(size, size_);
             err = lfs_bd_read(lfs,
                     &lfs->pcache, &lfs->rcache, delta,
-                    rbyd.block, off_, buffer, delta);
+                    branch.block, off_, buffer, delta);
             if (err) {
                 return err;
             }
@@ -2959,19 +3097,18 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
 
 static lfs_ssize_t lfsr_btree_find(lfs_t *lfs,
         const lfsr_btree_t *btree, const char *name, lfs_size_t name_len,
-        lfs_size_t *id_, lfsr_tag_t *tag_, lfs_size_t *weight_,
+        lfs_size_t *bid_, lfsr_tag_t *tag_, lfs_size_t *weight_,
         void *buffer, lfs_size_t size) {
     return lfsr_btree_find_(lfs, btree, name, name_len,
-            id_, NULL, NULL, tag_, weight_,
+            bid_, NULL, NULL, tag_, weight_,
             buffer, size);
 }
 
 static int lfsr_btree_commit(lfs_t *lfs,
-        lfsr_btree_t *btree, lfs_size_t id, lfsr_rbyd_t *rbyd,
+        lfsr_btree_t *btree, lfs_size_t bid, lfsr_rbyd_t *rbyd,
         const lfsr_attr_t *attrs, lfs_size_t attr_count) {
     // other layers should check for inlined btrees before this
-    LFS_ASSERT(!btree->tag);
-    LFS_ASSERT(rbyd->trunk);
+    LFS_ASSERT(lfsr_btree_istree(btree));
 
     // TODO should upper btree layers provide this storage? reuse
     // with entry attrs?
@@ -2983,7 +3120,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
         // we will always need our parent, so go ahead and find it
         lfsr_rbyd_t parent;
         lfs_ssize_t rid;
-        int err = lfsr_btree_parent(lfs, btree, id, rbyd, &parent, &rid);
+        int err = lfsr_btree_parent(lfs, btree, bid, rbyd, &parent, &rid);
         if (err && err != LFS_ERR_NOENT) {
             return err;
         }
@@ -2992,6 +3129,19 @@ static int lfsr_btree_commit(lfs_t *lfs,
         }
         lfs_size_t rweight = rbyd->weight;
 
+        // fetch our rbyd so we can mutate it
+        //
+        // note that some paths lead us to a recently allocated rbyd, these
+        // will fail to fetch so we need to check that this rbyd is unfetched
+        //
+        // strange benefit is we cache the root of our btree this way
+        if (!lfsr_rbyd_isfetched(rbyd)) {
+            err = lfsr_rbyd_fetch(lfs, rbyd, rbyd->block, rbyd->trunk, NULL);
+            if (err) {
+                return err;
+            }
+        }
+
         // is rbyd erased? can we sneak our commit into any remaining
         // erased bytes? note that the btree limit prevents this from mutating
         // other references to the rbyd
@@ -3012,24 +3162,22 @@ static int lfsr_btree_commit(lfs_t *lfs,
         }
 
         // prepare commit to parent, tail recursing upwards
-        lfs_ssize_t delta = lfsr_branch_todisk(
-                &(const lfsr_branch_t){rbyd->block, rbyd->off},
-                scratch_buf1);
-        if (delta < 0) {
-            return delta;
+        lfs_ssize_t d = lfsr_branch_todisk(rbyd, scratch_buf1);
+        if (d < 0) {
+            return d;
         }
 
         // note that since we defer merges to compaction time, we can
         // end up removing an rbyd here
         if (rbyd->weight == 0) {
             scratch_attrs[0] = LFSR_ATTR(
-                    rid, MKUNR, +rbyd->weight-rweight, scratch_buf1, delta);
+                    rid, MKUNR, +rbyd->weight-rweight, scratch_buf1, d);
 
             attrs = scratch_attrs;
             attr_count = 1;
         } else {
             scratch_attrs[0] = LFSR_ATTR(
-                    rid, BRANCH, 0, scratch_buf1, delta);
+                    rid, BRANCH, 0, scratch_buf1, d);
             scratch_attrs[1] = LFSR_ATTR(
                     rid, UNR, +rbyd->weight-rweight, NULL, 0);
 
@@ -3042,6 +3190,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
 
         // no? try to compact
     compact:;
+        printf("B COMPACT\n");
         // TODO were we doing something funky with rev?
         // first allocate a new rbyd
         lfsr_rbyd_t rbyd_;
@@ -3133,24 +3282,22 @@ static int lfsr_btree_commit(lfs_t *lfs,
         }
 
         // prepare commit to parent, tail recursing upwards
-        delta = lfsr_branch_todisk(
-                &(const lfsr_branch_t){rbyd_.block, rbyd_.off},
-                scratch_buf1);
-        if (delta < 0) {
-            return delta;
+        d = lfsr_branch_todisk(&rbyd_, scratch_buf1);
+        if (d < 0) {
+            return d;
         }
 
         // note that since we defer merges to compaction time, we can
         // end up removing an rbyd here
         if (rbyd_.weight == 0) {
             scratch_attrs[0] = LFSR_ATTR(
-                    rid, MKUNR, +rbyd_.weight-rweight, scratch_buf1, delta);
+                    rid, MKUNR, +rbyd_.weight-rweight, scratch_buf1, d);
 
             attrs = scratch_attrs;
             attr_count = 1;
         } else {
             scratch_attrs[0] = LFSR_ATTR(
-                    rid, BRANCH, 0, scratch_buf1, delta);
+                    rid, BRANCH, 0, scratch_buf1, d);
             scratch_attrs[1] = LFSR_ATTR(
                     rid, UNR, +rbyd_.weight-rweight, NULL, 0);
 
@@ -3162,6 +3309,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
         continue;
 
     split:;
+        printf("B SPLIT\n");
         // find out which id we need to split around
         lfs_ssize_t bisect = lfsr_rbyd_bisect(lfs, rbyd);
         if (bisect < 0) {
@@ -3292,23 +3440,17 @@ static int lfsr_btree_commit(lfs_t *lfs,
         
             // TODO this can also probably be deduplicated
             // prepare commit to parent, tail recursing upwards
-            lfs_ssize_t delta1 = lfsr_branch_todisk(
-                    &(const lfsr_branch_t){
-                        rbyd_.block, rbyd_.off},
-                    scratch_buf1);
-            if (delta1 < 0) {
-                return delta1;
+            lfs_ssize_t d1 = lfsr_branch_todisk(&rbyd_, scratch_buf1);
+            if (d1 < 0) {
+                return d1;
             }
-            lfs_ssize_t delta2 = lfsr_branch_todisk(
-                    &(const lfsr_branch_t){
-                        sibling.block, sibling.off},
-                    scratch_buf2);
-            if (delta2 < 0) {
-                return delta2;
+            lfs_ssize_t d2 = lfsr_branch_todisk(&sibling, scratch_buf2);
+            if (d2 < 0) {
+                return d2;
             }
 
             scratch_attrs[0] = LFSR_ATTR(
-                    0, MKBRANCH, +rbyd_.weight, scratch_buf1, delta1);
+                    0, MKBRANCH, +rbyd_.weight, scratch_buf1, d1);
 
             if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) {
                 scratch_attrs[1] = LFSR_ATTR_DISK(
@@ -3316,14 +3458,14 @@ static int lfsr_btree_commit(lfs_t *lfs,
                             sibling.block, soff, ssize);
                 scratch_attrs[2] = LFSR_ATTR(
                         0+rbyd_.weight+sibling.weight-1, BRANCH, 0,
-                            scratch_buf2, delta2);
+                            scratch_buf2, d2);
 
                 attrs = scratch_attrs;
                 attr_count = 3;
             } else {
                 scratch_attrs[1] = LFSR_ATTR(
                         0+rbyd_.weight, MKBRANCH, +sibling.weight,
-                            scratch_buf2, delta2);
+                            scratch_buf2, d2);
 
                 attrs = scratch_attrs;
                 attr_count = 2;
@@ -3332,26 +3474,20 @@ static int lfsr_btree_commit(lfs_t *lfs,
         // yes parent? push up split
         } else {
             // prepare commit to parent, tail recursing upwards
-            lfs_ssize_t delta1 = lfsr_branch_todisk(
-                    &(const lfsr_branch_t){
-                        rbyd_.block, rbyd_.off},
-                    scratch_buf1);
-            if (delta1 < 0) {
-                return delta1;
+            lfs_ssize_t d1 = lfsr_branch_todisk(&rbyd_, scratch_buf1);
+            if (d1 < 0) {
+                return d1;
             }
-            lfs_ssize_t delta2 = lfsr_branch_todisk(
-                    &(const lfsr_branch_t){
-                        sibling.block, sibling.off},
-                    scratch_buf2);
-            if (delta2 < 0) {
-                return delta2;
+            lfs_ssize_t d2 = lfsr_branch_todisk(&sibling, scratch_buf2);
+            if (d2 < 0) {
+                return d2;
             }
 
             scratch_attrs[0] = LFSR_ATTR(
                     rid, UNR, +rbyd_.weight-rweight, NULL, 0);
             scratch_attrs[1] = LFSR_ATTR(
                     rid-(rweight-1)+rbyd_.weight-1, BRANCH, 0,
-                        scratch_buf1, delta1);
+                        scratch_buf1, d1);
 
             if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) {
                 scratch_attrs[2] = LFSR_ATTR_DISK(
@@ -3361,7 +3497,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
                 scratch_attrs[3] = LFSR_ATTR(
                         rid-(rweight-1)+rbyd_.weight+sibling.weight-1, BRANCH,
                             0,
-                            scratch_buf2, delta2);
+                            scratch_buf2, d2);
 
                 attrs = scratch_attrs;
                 attr_count = 4;
@@ -3369,7 +3505,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
                 scratch_attrs[2] = LFSR_ATTR(
                         rid-(rweight-1)+rbyd_.weight, MKBRANCH,
                             +sibling.weight,
-                            scratch_buf2, delta2);
+                            scratch_buf2, d2);
 
                 attrs = scratch_attrs;
                 attr_count = 3;
@@ -3380,6 +3516,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
         continue;
 
     merge:;
+        printf("B MERGE\n");
         // last child? try the left sibling
         // lfs_ssize_t sid;
         lfs_ssize_t sdelta;
@@ -3420,23 +3557,17 @@ static int lfsr_btree_commit(lfs_t *lfs,
         }
 
         uint8_t buf[LFSR_BRANCH_DSIZE];
-        delta = lfs_min(LFSR_BRANCH_DSIZE, size);
+        d = lfs_min(LFSR_BRANCH_DSIZE, size);
         err = lfs_bd_read(lfs,
-                &lfs->pcache, &lfs->rcache, delta,
-                parent.block, off, buf, delta);
+                &lfs->pcache, &lfs->rcache, d,
+                parent.block, off, buf, d);
         if (err) {
             return err;
         }
 
-        lfsr_branch_t branch;
-        delta = lfsr_branch_fromdisk(&branch, buf);
-        if (delta < 0) {
-            return delta;
-        }
-
-        err = lfsr_rbyd_fetch(lfs, &sibling, branch.block, branch.limit, NULL);
-        if (err) {
-            return err;
+        d = lfsr_branch_fromdisk(&sibling, sweight, buf);
+        if (d < 0) {
+            return d;
         }
 
         // try to add our sibling's tags to our rbyd
@@ -3515,22 +3646,18 @@ static int lfsr_btree_commit(lfs_t *lfs,
 
         // we must have a parent at this point, but is our parent degenerate?
         LFS_ASSERT(rid != -1);
-        if (rweight+sweight == btree->weight) {
+        if (rweight+sweight == lfsr_btree_weight(btree)) {
             // collapse our parent, decreasing the height of the tree
-            LFS_ASSERT(btree->u.trunk.block == parent.block
-                    && btree->u.trunk.limit == parent.off);
-            btree->weight = rbyd_.weight;
-            btree->u.trunk.block = rbyd_.block;
-            btree->u.trunk.limit = rbyd_.off;
+            LFS_ASSERT(btree->root.block == parent.block
+                    && btree->root.trunk == parent.trunk);
+            btree->root = rbyd_;
             return 0;
 
         } else {
             // push up merge
-            lfs_ssize_t delta1 = lfsr_branch_todisk(
-                    &(const lfsr_branch_t){rbyd_.block, rbyd_.off},
-                    scratch_buf1);
-            if (delta1 < 0) {
-                return delta1;
+            lfs_ssize_t d1 = lfsr_branch_todisk(&rbyd_, scratch_buf1);
+            if (d1 < 0) {
+                return d1;
             }
 
             // make rid the lower child so the following math is easier
@@ -3542,7 +3669,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
             scratch_attrs[0] = LFSR_ATTR(
                     sid, MKUNR, -sweight, NULL, 0);
             scratch_attrs[1] = LFSR_ATTR(
-                    rid, BRANCH, 0, scratch_buf1, delta1);
+                    rid, BRANCH, 0, scratch_buf1, d1);
             scratch_attrs[2] = LFSR_ATTR(
                     rid, UNR, +rbyd_.weight-rweight, NULL, 0);
 
@@ -3555,31 +3682,29 @@ static int lfsr_btree_commit(lfs_t *lfs,
     }
 
     // at this point rbyd should be the trunk of our tree
-    btree->weight = rbyd->weight;
-    btree->u.trunk.block = rbyd->block;
-    btree->u.trunk.limit = rbyd->off;
+    btree->root = *rbyd;
     return 0;
 }
 
 static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree,
-        lfs_size_t id, lfsr_tag_t tag, lfs_size_t weight,
+        lfs_size_t bid, lfsr_tag_t tag, lfs_size_t weight,
         const void *buffer, lfs_size_t size) {
-    LFS_ASSERT(id <= btree->weight);
+    LFS_ASSERT(bid <= lfsr_btree_weight(btree));
 
     // null btree?
-    if (btree->weight == 0) {
-        LFS_ASSERT(id == 0);
+    if (lfsr_btree_isnull(btree)) {
+        LFS_ASSERT(bid == 0);
 
-        btree->tag = tag;
-        btree->weight = weight;
+        btree->weight = -weight;
+        btree->inlined.tag = tag;
 
         LFS_ASSERT(size <= LFSR_BTREE_INLINE_SIZE);
-        memcpy(btree->u.inlined.buf, buffer, size);
-        btree->u.inlined.size = size;
+        memcpy(btree->inlined.buf, buffer, size);
+        btree->inlined.len = size;
         return 0;
 
     // inlined btree, need to expand into an rbyd
-    } else if (btree->tag) {
+    } else if (lfsr_btree_isinlined(btree)) {
         lfsr_rbyd_t rbyd;
         int err = lfsr_rbyd_alloc(lfs, &rbyd, 1);
         if (err) {
@@ -3589,19 +3714,17 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree,
         // commit our entries
         err = lfsr_rbyd_commit(lfs, &rbyd, LFSR_ATTRS(
                 LFSR_ATTR_(
-                    0, lfsr_tag_setmk(btree->tag), +btree->weight,
-                    btree->u.inlined.buf, btree->u.inlined.size),
+                    0, lfsr_tag_setmk(btree->inlined.tag),
+                    +lfsr_btree_weight(btree),
+                    btree->inlined.buf, btree->inlined.len),
                 LFSR_ATTR_(
-                    id, lfsr_tag_setmk(tag), +weight,
+                    bid, lfsr_tag_setmk(tag), +weight,
                     buffer, size)));
         if (err) {
             return err;
         }
 
-        btree->tag = 0;
-        btree->weight = rbyd.weight;
-        btree->u.trunk.block = rbyd.block;
-        btree->u.trunk.limit = rbyd.off;
+        btree->root = rbyd;
         return 0;
 
     // a normal btree
@@ -3611,14 +3734,14 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree,
         lfs_ssize_t rid;
         lfs_size_t rweight;
         lfs_ssize_t size = lfsr_btree_lookup(lfs, btree,
-                lfs_min32(id, btree->weight-1),
-                NULL, &rbyd, &rid, NULL, &rweight, NULL, 0);
+                lfs_min32(bid, lfsr_btree_weight(btree)-1),
+                NULL, &rbyd, &rid, NULL, &rweight, NULL, 0, false);
         if (size < 0) {
             return size;
         }
 
         // adjust rid for push
-        if (id >= btree->weight) {
+        if (bid >= lfsr_btree_weight(btree)) {
             rid += 1;
         } else {
             rid -= rweight-1;
@@ -3627,27 +3750,27 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree,
         // commit our id into the tree, letting lfsr_btree_commit take care
         // of the rest
         return lfsr_btree_commit(lfs, btree,
-                lfs_min32(id, btree->weight-1), &rbyd, LFSR_ATTRS(
+                lfs_min32(bid, lfsr_btree_weight(btree)-1), &rbyd, LFSR_ATTRS(
                     LFSR_ATTR_(rid, lfsr_tag_setmk(tag), +weight,
                         buffer, size)));
     }
 }
 
 static int lfsr_btree_update(lfs_t *lfs, lfsr_btree_t *btree,
-        lfs_size_t id, lfsr_tag_t tag, lfs_size_t weight,
+        lfs_size_t bid, lfsr_tag_t tag, lfs_size_t weight,
         const void *buffer, lfs_size_t size) {
-    LFS_ASSERT(id < btree->weight);
+    LFS_ASSERT(bid < lfsr_btree_weight(btree));
 
     // inlined btree?
-    if (btree->tag) {
-        LFS_ASSERT(id == btree->weight-1);
+    if (lfsr_btree_isinlined(btree)) {
+        LFS_ASSERT(bid == lfsr_btree_weight(btree)-1);
 
-        btree->tag = tag;
-        btree->weight = weight;
+        btree->weight = -weight;
+        btree->inlined.tag = tag;
 
         LFS_ASSERT(size <= LFSR_BTREE_INLINE_SIZE);
-        memcpy(btree->u.inlined.buf, buffer, size);
-        btree->u.inlined.size = size;
+        memcpy(btree->inlined.buf, buffer, size);
+        btree->inlined.len = size;
         return 0;
 
     // a normal btree
@@ -3657,15 +3780,15 @@ static int lfsr_btree_update(lfs_t *lfs, lfsr_btree_t *btree,
         lfsr_tag_t rtag;
         lfs_ssize_t rid;
         lfs_size_t rweight;
-        lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id,
-                NULL, &rbyd, &rid, &rtag, &rweight, NULL, 0);
+        lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, bid,
+                NULL, &rbyd, &rid, &rtag, &rweight, NULL, 0, false);
         if (size < 0) {
             return size;
         }
 
         // commit our id into the tree, letting lfsr_btree_commit take care
         // of the rest
-        return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS(
+        return lfsr_btree_commit(lfs, btree, bid, &rbyd, LFSR_ATTRS(
                 (tag != rtag
                     ? LFSR_ATTR_(rid, lfsr_tag_setrm(rtag), 0, NULL, 0)
                     : LFSR_ATTR_NOOP),
@@ -3674,12 +3797,12 @@ static int lfsr_btree_update(lfs_t *lfs, lfsr_btree_t *btree,
     }
 }
 
-static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) {
-    LFS_ASSERT(id < btree->weight);
+static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) {
+    LFS_ASSERT(bid < lfsr_btree_weight(btree));
 
     // inlined btree?
-    if (btree->tag) {
-        LFS_ASSERT(id == btree->weight-1);
+    if (lfsr_btree_isinlined(btree)) {
+        LFS_ASSERT(bid == lfsr_btree_weight(btree)-1);
         btree->weight = 0;
         return 0;
 
@@ -3690,15 +3813,15 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) {
         lfsr_tag_t rtag;
         lfs_ssize_t rid;
         lfs_size_t rweight;
-        lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id,
-                NULL, &rbyd, &rid, &rtag, &rweight, NULL, 0);
+        lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, bid,
+                NULL, &rbyd, &rid, &rtag, &rweight, NULL, 0, false);
         if (size < 0) {
             return size;
         }
 
         // can we collapse into an inlined btree?
-        if (btree->u.trunk.block == rbyd.block
-                && btree->u.trunk.limit == rbyd.off) {
+        if (btree->root.block == rbyd.block
+                && btree->root.trunk == rbyd.trunk) {
             // last child? try the left sibling
             lfs_ssize_t sid;
             if ((lfs_size_t)rid == rbyd.weight-1) {
@@ -3739,24 +3862,25 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) {
             }
 
             // one sibling? inline!
-            if (rweight + sweight == btree->weight) {
-                btree->tag = stag;
-                btree->weight = sweight;
+            if (rweight + sweight == lfsr_btree_weight(btree)) {
+                btree->weight = -sweight;
+                btree->inlined.tag = stag;
+
                 LFS_ASSERT(size <= LFSR_BTREE_INLINE_SIZE);
                 err = lfs_bd_read(lfs,
                         &lfs->pcache, &lfs->rcache, size,
-                        rbyd.block, off, btree->u.inlined.buf, size);
+                        rbyd.block, off, btree->inlined.buf, size);
                 if (err) {
                     return err;
                 }
-                btree->u.inlined.size = size;
+                btree->inlined.len = size;
                 return 0;
             }
         }
 
         // remove our id, letting lfsr_btree_commit take care
         // of the rest
-        return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS(
+        return lfsr_btree_commit(lfs, btree, bid, &rbyd, LFSR_ATTRS(
                 LFSR_ATTR(rid, MKUNR, -rweight, NULL, 0)));
     }
 }
@@ -3768,16 +3892,16 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) {
 // push/update could as well, we just don't need the functionality for littlefs
 //
 static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree,
-        lfs_size_t id,
+        lfs_size_t bid,
         const char *name, lfs_size_t name_len,
         lfsr_tag_t tag1, lfs_size_t weight1,
         const void *buffer1, lfs_size_t size1,
         lfsr_tag_t tag2, lfs_size_t weight2,
         const void *buffer2, lfs_size_t size2) {
-    LFS_ASSERT(id < btree->weight);
+    LFS_ASSERT(bid < lfsr_btree_weight(btree));
 
     // inlined btree, need to expand into an rbyd
-    if (btree->tag) {
+    if (lfsr_btree_isinlined(btree)) {
         lfsr_rbyd_t rbyd;
         int err = lfsr_rbyd_alloc(lfs, &rbyd, 1);
         if (err) {
@@ -3796,37 +3920,24 @@ static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        btree->tag = 0;
-        btree->weight = rbyd.weight;
-        btree->u.trunk.block = rbyd.block;
-        btree->u.trunk.limit = rbyd.off;
+        btree->root = rbyd;
         return 0;
 
     // a normal btree
     } else {
-        // lookup in which leaf our id resides
+        // lookup in which leaf our bid resides
         lfsr_rbyd_t rbyd;
         lfs_ssize_t rid;
         lfs_size_t rweight;
-//        // TODO should we have two split functions?
-//        // TODO should we bother with id splits if we usually split on names?
-//        if (name_len == 0) {
-            lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id,
-                    NULL, &rbyd, &rid, NULL, &rweight, NULL, 0);
-            if (size < 0) {
-                return size;
-            }
-//        } else {
-//            lfs_ssize_t size = lfsr_btree_find_(lfs, btree, name, name_len,
-//                    NULL, &id, &rbyd, &rid, &rweight, NULL, 0);
-//            if (size < 0) {
-//                return size;
-//            }
-//        }
+        lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, bid,
+                NULL, &rbyd, &rid, NULL, &rweight, NULL, 0, false);
+        if (size < 0) {
+            return size;
+        }
 
-        // commit our id into the tree, letting lfsr_btree_commit take care
+        // commit our bid into the tree, letting lfsr_btree_commit take care
         // of the rest
-        return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS(
+        return lfsr_btree_commit(lfs, btree, bid, &rbyd, LFSR_ATTRS(
                 LFSR_ATTR(rid, UNR, +weight1-rweight, NULL, 0),
                 LFSR_ATTR_(rid-(rweight-1)+weight1-1, tag1, 0,
                     buffer1, size1),
diff --git a/lfs.h b/lfs.h
index ca2a5763..5c499ea1 100644
--- a/lfs.h
+++ b/lfs.h
@@ -330,12 +330,16 @@ typedef struct lfs_cache {
     uint8_t *buffer;
 } lfs_cache_t;
 
+// TODO do we get ram savings with a lfsr_rorbyd_t substruct? need to measure
 typedef struct lfsr_rbyd {
+    // note this lines up with weight in lfsr_btree_t
+    lfs_size_t weight;
     lfs_block_t block;
+    // off=0, trunk=0 => not yet committed
+    // off=0, trunk>0 => not yet fetched
     // off=block_size => rbyd not erased/needs compaction
     lfs_off_t off;
     lfs_off_t trunk;
-    lfs_size_t weight;
     uint32_t rev;
     uint32_t crc;
 } lfsr_rbyd_t;
@@ -358,27 +362,43 @@ typedef struct lfsr_rbyd {
 // - block addresses => 1 leb128 => 5 bytes (worst case)
 #define LFSR_BTREE_INLINE_SIZE 5
 
-typedef struct lfsr_branch {
-    lfs_block_t block;
-    lfs_size_t limit;
-} lfsr_branch_t;
-
-typedef struct lfsr_btree {
-    lfs_size_t weight;
-    // TODO do we need full tag actually? this fits in a byte?
-    lfsr_tag_t tag;
-    // how can we take advantage of byte packing with union alignment?
-    union {
-        struct {
-            uint8_t size;
-            uint8_t buf[LFSR_BTREE_INLINE_SIZE];
-        } inlined;
-
-        // if we're not inlined, point to the trunk rbyd block of the btree
-        lfsr_branch_t trunk;
-    } u;
+typedef union lfsr_btree {
+    // note this lines up with weight in lfsr_rbyd_t
+    //
+    // weight=0 => null btree
+    // weight<0 => inlined btree
+    // weight>0 => normal btree
+    lfs_ssize_t weight;
+    lfsr_rbyd_t root;
+    struct {
+        lfs_ssize_t weight;
+        lfsr_tag_t tag;
+        uint16_t len;
+        uint8_t buf[LFSR_BTREE_INLINE_SIZE];
+    } inlined;
 } lfsr_btree_t;
 
+//typedef struct lfsr_branch {
+//    lfs_block_t block;
+//    lfs_size_t limit;
+//} lfsr_branch_t;
+//
+//typedef struct lfsr_btree {
+//    lfs_size_t weight;
+//    // TODO do we need full tag actually? this fits in a byte?
+//    lfsr_tag_t tag;
+//    // how can we take advantage of byte packing with union alignment?
+//    union {
+//        struct {
+//            uint8_t size;
+//            uint8_t buf[LFSR_BTREE_INLINE_SIZE];
+//        } inlined;
+//
+//        // if we're not inlined, point to the trunk rbyd block of the btree
+//        lfsr_branch_t trunk;
+//    } u;
+//} lfsr_btree_t;
+
 typedef struct lfs_mdir {
     lfs_block_t pair[2];
     uint32_t rev;
diff --git a/lfs_util.h b/lfs_util.h
index 5879acdc..058b8e0f 100644
--- a/lfs_util.h
+++ b/lfs_util.h
@@ -146,6 +146,11 @@ static inline uint16_t lfs_min16(uint16_t a, uint16_t b) {
     return (a < b) ? a : b;
 }
 
+// Absolute value of signed numbers
+static inline int32_t lfs_abs32(int32_t a) {
+    return a < 0 ? -a : a;
+}
+
 // TODO how many of these do we actually need
 // Swap two 16-bit numbers
 static inline void lfs_swap16(uint16_t *a, uint16_t *b) {
diff --git a/scripts/dbgbtree.py b/scripts/dbgbtree.py
index 6722195f..f8967fe9 100755
--- a/scripts/dbgbtree.py
+++ b/scripts/dbgbtree.py
@@ -22,7 +22,7 @@ TAG_ALT     = 0x0008
 TAG_CRC     = 0x0004
 TAG_FCRC    = 0x1004
 
-def blocklim(s):
+def rbydaddr(s):
     if '.' in s:
         s = s.strip()
         b = 10
@@ -50,9 +50,10 @@ def crc32c(data, crc=0):
     return 0xffffffff ^ crc
 
 def fromle16(data):
-    if len(data) < 2:
-        return 0
-    return struct.unpack('<H', data[:2])[0]
+    return struct.unpack('<H', data[0:2].ljust(2, b'\0'))[0]
+
+def fromle32(data):
+    return struct.unpack('<I', data[0:4].ljust(4, b'\0'))[0]
 
 def fromleb128(data):
     word = 0
@@ -65,9 +66,9 @@ def fromleb128(data):
 
 def fromtag(data):
     tag = fromle16(data)
-    weight, delta = fromleb128(data[2:])
-    size, delta_ = fromleb128(data[2+delta:])
-    return tag&1, tag&~1, weight, size, 2+delta+delta_
+    weight, d = fromleb128(data[2:])
+    size, d_ = fromleb128(data[2+d:])
+    return tag&1, tag&~1, weight, size, 2+d+d_
 
 def popc(x):
     return bin(x).count('1')
@@ -134,9 +135,8 @@ def tagrepr(tag, w, size, off=None):
         return '0x%04x w%d %d' % (tag, w, size)
 
 class Rbyd:
-    def __init__(self, block, limit, data, rev, off, trunk, weight):
+    def __init__(self, block, data, rev, off, trunk, weight):
         self.block = block
-        self.limit = limit
         self.data = data
         self.rev = rev
         self.off = off
@@ -144,60 +144,74 @@ class Rbyd:
         self.weight = weight
 
     @classmethod
-    def fetch(cls, f, block_size, block, limit):
+    def fetch(cls, f, block_size, block, trunk):
         # seek to the block
         f.seek(block * block_size)
-        data = f.read(limit)
+        data = f.read(block_size)
 
         # fetch the rbyd
-        rev, = struct.unpack('<I', data[0:4].ljust(4, b'\0'))
-        crc = crc32c(data[0:4])
+        rev = fromle32(data[0:4])
+        crc = 0
+        crc_ = crc32c(data[0:4])
         off = 0
         j_ = 4
-        trunk = None
-        trunk_ = None
+        trunk_ = 0
+        trunk__ = 0
         weight = 0
         lower_, upper_ = 0, 0
         weight_ = 0
         wastrunk = False
-        while j_ < limit:
-            v, tag, w, size, delta = fromtag(data[j_:])
-            if v != (popc(crc) & 1):
+        trunkoff = None
+        while j_ < len(data) and (not trunk or off <= trunk):
+            v, tag, w, size, d = fromtag(data[j_:])
+            if v != (popc(crc_) & 1):
+                break
+            crc_ = crc32c(data[j_:j_+d], crc_)
+            j_ += d
+            if not tag & 0x8 and j_ + size > len(data):
                 break
-            crc = crc32c(data[j_:j_+delta], crc)
-            j_ += delta
-
-            # find trunk
-            if not wastrunk and (tag & 0xc) != 0x4:
-                trunk_ = j_ - delta
-                lower_, upper_ = 0, 0
-            wastrunk = not not tag & 0x8
-
-            # keep track of weight
-            if tag & 0x8:
-                if tag & 0x4:
-                    upper_ += w
-                else:
-                    lower_ += w
-            elif (tag & 0xc) == 0x0:
-                weight_ = lower_+upper_+w
 
             # take care of crcs
             if not tag & 0x8:
                 if (tag & 0xf00f) != TAG_CRC:
-                    crc = crc32c(data[j_:j_+size], crc)
+                    crc_ = crc32c(data[j_:j_+size], crc_)
                 # found a crc?
                 else:
-                    crc_, = struct.unpack('<I', data[j_:j_+4].ljust(4, b'\0'))
-                    if crc != crc_:
+                    crc__ = fromle32(data[j_:j_+4])
+                    if crc_ != crc__:
                         break
                     # commit what we have
-                    off = j_ + size
-                    trunk = trunk_
+                    off = trunkoff if trunkoff else j_ + size
+                    crc = crc_
+                    trunk_ = trunk__
                     weight = weight_
+
+            # evaluate trunks
+            if (tag & 0xc) != 0x4 and (
+                    not trunk or trunk >= j_-d or wastrunk):
+                # new trunk?
+                if not wastrunk:
+                    trunk__ = j_-d
+                    lower_, upper_ = 0, 0
+                    wastrunk = True
+
+                # keep track of weight
+                if tag & 0x8:
+                    if tag & 0x4:
+                        upper_ += w
+                    else:
+                        lower_ += w
+                else:
+                    weight_ = lower_+upper_+w
+                    wastrunk = False
+                    # keep track of off for best matching trunk
+                    if trunk and j_ + size > trunk:
+                        trunkoff = j_ + size
+
+            if not tag & 0x8:
                 j_ += size
 
-        return Rbyd(block, limit, data, rev, off, trunk, weight)
+        return Rbyd(block, data, rev, off, trunk_, weight)
 
     def lookup(self, id, tag):
         if not self:
@@ -209,7 +223,7 @@ class Rbyd:
         # descend down tree
         j = self.trunk
         while True:
-            _, alt, weight_, jump, delta = fromtag(self.data[j:])
+            _, alt, weight_, jump, d = fromtag(self.data[j:])
 
             # found an alt?
             if alt & 0x8:
@@ -224,7 +238,7 @@ class Rbyd:
                 else:
                     lower += weight_ if not alt & 0x4 else 0
                     upper -= weight_ if alt & 0x4 else 0
-                    j = j + delta
+                    j = j + d
             # found tag
             else:
                 id_ = upper-1
@@ -234,13 +248,13 @@ class Rbyd:
                 done = (id_, tag_) < (id, tag) or tag_ & 2
 
                 return (done, id_, tag_, w_,
-                    j, delta, self.data[j+delta:j+delta+jump])
+                    j, d, self.data[j+d:j+d+jump])
 
     def __bool__(self):
-        return self.trunk is not None
+        return bool(self.trunk)
 
     def __eq__(self, other):
-        return self.block == other.block and self.limit == other.limit
+        return self.block == other.block and self.trunk == other.trunk
 
     def __ne__(self, other):
         return not self.__eq__(other)
@@ -257,7 +271,9 @@ class Rbyd:
             yield id, tag, w, j, d, data
 
 
-def main(disk, block_size=None, trunk=0, limit=None, *,
+def main(disk, root=0, *,
+        block_size=None,
+        trunk=None,
         color='auto',
         **args):
     # figure out what color should be
@@ -268,11 +284,11 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
     else:
         color = False
 
-    # trunk may include a limit
-    if isinstance(trunk, tuple):
-        if limit is None:
-            limit = trunk[1]
-        trunk = trunk[0]
+    # root may encode a trunk
+    if isinstance(root, tuple):
+        if trunk is None:
+            trunk = root[1]
+        root = root[0]
 
     # we seek around a bunch, so just keep the disk open
     with open(disk, 'rb') as f:
@@ -281,18 +297,14 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
             f.seek(0, os.SEEK_END)
             block_size = f.tell()
 
-        # default limit to the block_size
-        if limit is None:
-            limit = block_size
-
-        # fetch the trunk
-        trunk = Rbyd.fetch(f, block_size, trunk, limit)
+        # fetch the root
+        btree = Rbyd.fetch(f, block_size, root, trunk)
         print('btree 0x%x.%x, rev %d, weight %d' % (
-            trunk.block, trunk.limit, trunk.rev, trunk.weight))
+            btree.block, btree.trunk, btree.rev, btree.weight))
 
         # look up an id, while keeping track of the search path
         def lookup(id, depth=None):
-            rbyd = trunk
+            rbyd = btree
             rid = id
             depth_ = 1
             path = []
@@ -337,9 +349,10 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
                 # is it another branch? continue down tree
                 if struct_tag == TAG_BRANCH and (
                         depth is None or depth_ < depth):
-                    block, delta = fromleb128(struct_)
-                    limit, _ = fromleb128(struct_[delta:])
-                    rbyd = Rbyd.fetch(f, block_size, block, limit)
+                    trunk, d1 = fromleb128(struct_)
+                    block, d2 = fromleb128(struct_[d1:])
+                    crc = fromle32(struct_[d1+d2:])
+                    rbyd = Rbyd.fetch(f, block_size, block, trunk)
 
                     # corrupted? bail here so we can keep traversing the tree
                     if not rbyd:
@@ -371,7 +384,7 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
                 t_depth = max(t_depth, len(path))
 
             t_width = 2*t_depth+2 if t_depth > 0 else 0
-            t_branches = [(0, trunk.weight)]
+            t_branches = [(0, btree.weight)]
 
             def treerepr(id, w, leaf=True, depth=None):
                 branches_ = []
@@ -427,7 +440,7 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
 
 
         # print header
-        w_width = 2*m.ceil(m.log10(max(1, trunk.weight)+1))+1
+        w_width = 2*m.ceil(m.log10(max(1, btree.weight)+1))+1
         print('%-9s  %*s%-*s %-22s  %s' % (
             'block',
             t_width, '',
@@ -448,7 +461,7 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
             # show human-readable representation
             if name_tag:
                 print('%10s %s%*s %-22s  %s' % (
-                    '%04x.%04x:' % (rbyd.block, rbyd.limit)
+                    '%04x.%04x:' % (rbyd.block, rbyd.trunk)
                         if prbyd is None or rbyd != prbyd
                         else '',
                     treerepr(id, w, True, depth) if args.get('tree') else '',
@@ -461,7 +474,7 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
                         for b in map(chr, name))))
                 prbyd = rbyd
             print('%10s %s%*s %-22s  %s' % (
-                '%04x.%04x:' % (rbyd.block, rbyd.limit)
+                '%04x.%04x:' % (rbyd.block, rbyd.trunk)
                     if prbyd is None or rbyd != prbyd
                     else '',
                 treerepr(id, w, not name_tag, depth) if args.get('tree') else '',
@@ -485,10 +498,9 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
                         w_width, '',
                         '%04x %08x %07x' % (name_tag, w, len(name)),
                         '  %s' % ' '.join(
-                            '%08x' % struct.unpack('<I',
+                            '%08x' % fromle32(
                                 rbyd.data[name_j+name_d+i*4
-                                    : name_j+name_d + min(i*4+4,len(name))]
-                                    .ljust(4, b'\0'))
+                                    : name_j+name_d + min(i*4+4,len(name))])
                             for i in range(min(m.ceil(len(name)/4), 3)))[:23]))
                 print('%9s  %*s%*s %-22s%s' % (
                     '',
@@ -497,10 +509,9 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
                     '%04x %08x %07x' % (
                         struct_tag, w if not name_tag else 0, len(struct_)),
                     '  %s' % ' '.join(
-                        '%08x' % struct.unpack('<I',
+                        '%08x' % fromle32(
                             rbyd.data[struct_j+struct_d+i*4
-                                : struct_j+struct_d + min(i*4+4,len(struct_))]
-                                .ljust(4, b'\0'))
+                                : struct_j+struct_d + min(i*4+4,len(struct_))])
                         for i in range(min(m.ceil(len(struct_)/4), 3)))[:23]))
 
             # show on-disk encoding of tags/data
@@ -550,7 +561,7 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
                 break
 
             if args.get('inner') or args.get('tree'):
-                t_branches = [(0, trunk.weight)]
+                t_branches = [(0, btree.weight)]
                 changed = False
                 for i, (x, px) in enumerate(
                         it.zip_longest(path[:-1], ppath[:-1])):
@@ -576,10 +587,10 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
             # corrupted? try to keep printing the tree
             if not rbyd:
                 print('%04x.%04x: %s%s%s%s' % (
-                    rbyd.block, rbyd.limit,
+                    rbyd.block, rbyd.trunk,
                     treerepr(id, w) if args.get('tree') else '',
                     '\x1b[31m' if color else '',
-                    '(corrupted rbyd 0x%x.%x)' % (rbyd.block, rbyd.limit),
+                    '(corrupted rbyd 0x%x.%x)' % (rbyd.block, rbyd.trunk),
                     '\x1b[m' if color else ''))
 
                 prbyd = rbyd
@@ -616,18 +627,18 @@ if __name__ == "__main__":
         'disk',
         help="File containing the block device.")
     parser.add_argument(
-        'trunk',
+        'root',
         nargs='?',
-        type=blocklim,
-        help="Block address of the trunk of the tree.")
+        type=rbydaddr,
+        help="Block address of the root of the tree.")
     parser.add_argument(
         '-B', '--block-size',
         type=lambda x: int(x, 0),
         help="Block size in bytes.")
     parser.add_argument(
-        '-L', '--limit',
+        '--trunk',
         type=lambda x: int(x, 0),
-        help="Rbyd limit of the trunk of the tree (alias).")
+        help="Use this offset as the trunk of the tree.")
     parser.add_argument(
         '--color',
         choices=['never', 'always', 'auto'],
diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py
index 8a455edc..cf6e11e6 100755
--- a/scripts/dbgrbyd.py
+++ b/scripts/dbgrbyd.py
@@ -32,7 +32,7 @@ TAG_ALT     = 0x0008
 TAG_CRC     = 0x0004
 TAG_FCRC    = 0x1004
 
-def blocklim(s):
+def rbydaddr(s):
     if '.' in s:
         s = s.strip()
         b = 10
@@ -60,9 +60,10 @@ def crc32c(data, crc=0):
     return 0xffffffff ^ crc
 
 def fromle16(data):
-    if len(data) < 2:
-        return 0
-    return struct.unpack('<H', data[:2])[0]
+    return struct.unpack('<H', data[0:2].ljust(2, b'\0'))[0]
+
+def fromle32(data):
+    return struct.unpack('<I', data[0:4].ljust(4, b'\0'))[0]
 
 def fromleb128(data):
     word = 0
@@ -75,9 +76,9 @@ def fromleb128(data):
 
 def fromtag(data):
     tag = fromle16(data)
-    weight, delta = fromleb128(data[2:])
-    size, delta_ = fromleb128(data[2+delta:])
-    return tag&1, tag&~1, weight, size, 2+delta+delta_
+    weight, d = fromleb128(data[2:])
+    size, d_ = fromleb128(data[2+d:])
+    return tag&1, tag&~1, weight, size, 2+d+d_
 
 def popc(x):
     return bin(x).count('1')
@@ -143,7 +144,7 @@ def tagrepr(tag, w, size, off=None):
     else:
         return '0x%04x w%d %d' % (tag, w, size)
 
-def show_log(block_size, data, rev, off, weight, *,
+def show_log(data, block_size, rev, off, weight, *,
         color=False,
         **args):
     crc = crc32c(data[0:4])
@@ -154,8 +155,8 @@ def show_log(block_size, data, rev, off, weight, *,
         j_ = 4
         while j_ < (block_size if args.get('all') else off):
             j = j_
-            v, tag, w, size, delta = fromtag(data[j_:])
-            j_ += delta
+            v, tag, w, size, d = fromtag(data[j_:])
+            j_ += d
             if not tag & 0x8:
                 j_ += size
 
@@ -251,8 +252,8 @@ def show_log(block_size, data, rev, off, weight, *,
         j_ = 4
         while j_ < (block_size if args.get('all') else off):
             j = j_
-            v, tag, w, size, delta = fromtag(data[j_:])
-            j_ += delta
+            v, tag, w, size, d = fromtag(data[j_:])
+            j_ += d
             if not tag & 0x8:
                 j_ += size
 
@@ -378,7 +379,11 @@ def show_log(block_size, data, rev, off, weight, *,
 
     # print revision count
     if args.get('raw'):
-        print('%8s: %s' % ('%04x' % 0, next(xxd(data[0:4]))))
+        print('%8s: %*s%*s %s' % (
+            '%04x' % 0,
+            lifetime_width, '',
+            w_width, '',
+            next(xxd(data[0:4]))))
 
     # print tags
     lower_, upper_ = 0, 0
@@ -388,12 +393,12 @@ def show_log(block_size, data, rev, off, weight, *,
         notes = []
 
         j = j_
-        v, tag, w, size, delta = fromtag(data[j_:])
+        v, tag, w, size, d = fromtag(data[j_:])
         if v != (popc(crc) & 1):
             notes.append('v!=%x' % (popc(crc) & 1))
         tag &= ~1
-        crc = crc32c(data[j_:j_+delta], crc)
-        j_ += delta
+        crc = crc32c(data[j_:j_+d], crc)
+        j_ += d
 
         # find trunk
         if not wastrunk and (tag & 0xc) != 0x4:
@@ -415,7 +420,7 @@ def show_log(block_size, data, rev, off, weight, *,
                 crc = crc32c(data[j_:j_+size], crc)
             # found a crc?
             else:
-                crc_, = struct.unpack('<I', data[j_:j_+4].ljust(4, b'\0'))
+                crc_ = fromle32(data[j_:j_+4])
                 if crc != crc_:
                     notes.append('crc!=%08x' % crc)
             j_ += size
@@ -433,7 +438,7 @@ def show_log(block_size, data, rev, off, weight, *,
             '%-22s%s' % (
                 tagrepr(tag, w, size, j),
                 '  %s' % next(xxd(
-                        data[j+delta:j+delta+min(size, 8)], 8), '')
+                        data[j+d:j+d+min(size, 8)], 8), '')
                     if not args.get('no_truncate')
                         and not tag & 0x8 else ''),
             '\x1b[m' if color and j >= off else '',
@@ -453,9 +458,8 @@ def show_log(block_size, data, rev, off, weight, *,
                 '%-22s%s' % (
                     '%04x %08x %07x' % (tag, w, size),
                     '  %s' % ' '.join(
-                            '%08x' % struct.unpack('<I',
-                                data[j+delta+i*4:j+delta+min(i*4+4,size)]
-                                    .ljust(4, b'\0'))
+                            '%08x' % fromle32(
+                                data[j+d+i*4:j+d+min(i*4+4,size)])
                             for i in range(min(m.ceil(size/4), 3)))[:23]
                         if not args.get('no_truncate')
                             and not tag & 0x8 else ''),
@@ -465,7 +469,7 @@ def show_log(block_size, data, rev, off, weight, *,
 
         # show on-disk encoding of tags
         if args.get('raw'):
-            for o, line in enumerate(xxd(data[j:j+delta])):
+            for o, line in enumerate(xxd(data[j:j+d])):
                 print('%s%8s: %*s%*s %s%s' % (
                     '\x1b[90m' if color and j >= off else '',
                     '%04x' % (j + o*16),
@@ -475,20 +479,20 @@ def show_log(block_size, data, rev, off, weight, *,
                     '\x1b[m' if color and j >= off else ''))
         if args.get('raw') or args.get('no_truncate'):
             if not tag & 0x8:
-                for o, line in enumerate(xxd(data[j+delta:j+delta+size])):
+                for o, line in enumerate(xxd(data[j+d:j+d+size])):
                     print('%s%8s: %*s%*s %s%s' % (
                         '\x1b[90m' if color and j >= off else '',
-                        '%04x' % (j+delta + o*16),
+                        '%04x' % (j+d + o*16),
                         lifetime_width, '',
                         w_width, '',
                         line,
                         '\x1b[m' if color and j >= off else ''))
 
 
-def show_tree(block_size, data, rev, trunk, weight, *,
+def show_tree(data, block_size, rev, trunk, weight, *,
         color=False,
         **args):
-    if trunk is None:
+    if not trunk:
         return
 
     # lookup a tag, returning also the search path for decoration
@@ -501,7 +505,7 @@ def show_tree(block_size, data, rev, trunk, weight, *,
         # descend down tree
         j = trunk
         while True:
-            _, alt, w, jump, delta = fromtag(data[j:])
+            _, alt, w, jump, d = fromtag(data[j:])
 
             # found an alt?
             if alt & 0x8:
@@ -516,7 +520,7 @@ def show_tree(block_size, data, rev, trunk, weight, *,
                     if args.get('tree'):
                         # figure out which color
                         if alt & 0x2:
-                            _, nalt, _, _, _ = fromtag(data[j+jump+delta:])
+                            _, nalt, _, _, _ = fromtag(data[j+jump+d:])
                             if nalt & 0x2:
                                 path.append((j+jump, j, True, 'y'))
                             else:
@@ -527,18 +531,18 @@ def show_tree(block_size, data, rev, trunk, weight, *,
                 else:
                     lower += w if not alt & 0x4 else 0
                     upper -= w if alt & 0x4 else 0
-                    j = j + delta
+                    j = j + d
 
                     if args.get('tree'):
                         # figure out which color
                         if alt & 0x2:
                             _, nalt, _, _, _ = fromtag(data[j:])
                             if nalt & 0x2:
-                                path.append((j-delta, j, False, 'y'))
+                                path.append((j-d, j, False, 'y'))
                             else:
-                                path.append((j-delta, j, False, 'r'))
+                                path.append((j-d, j, False, 'r'))
                         else:
-                            path.append((j-delta, j, False, 'b'))
+                            path.append((j-d, j, False, 'b'))
             # found tag
             else:
                 id_ = upper-1
@@ -547,7 +551,7 @@ def show_tree(block_size, data, rev, trunk, weight, *,
 
                 done = (id_, tag_) < (id, tag) or tag_ & 2
 
-                return done, id_, tag_, w_, j, delta, jump, path
+                return done, id_, tag_, w_, j, d, jump, path
 
     # precompute tree
     tree_width = 0
@@ -557,7 +561,7 @@ def show_tree(block_size, data, rev, trunk, weight, *,
 
         id, tag = -1, 0
         while True:
-            done, id, tag, w, j, delta, size, path = lookup(id, tag+0x10)
+            done, id, tag, w, j, d, size, path = lookup(id, tag+0x10)
             # found end of tree?
             if done:
                 break
@@ -692,7 +696,7 @@ def show_tree(block_size, data, rev, trunk, weight, *,
 
     id, tag = -1, 0
     while True:
-        done, id, tag, w, j, delta, size, path = lookup(id, tag+0x10)
+        done, id, tag, w, j, d, size, path = lookup(id, tag+0x10)
         # found end of tree?
         if done:
             break
@@ -707,7 +711,7 @@ def show_tree(block_size, data, rev, trunk, weight, *,
                     if w > 0 else '',
                 tagrepr(tag, w, size, j),
                 '  %s' % next(xxd(
-                        data[j+delta:j+delta+min(size, 8)], 8), '')
+                        data[j+d:j+d+min(size, 8)], 8), '')
                     if not args.get('no_truncate')
                         and not tag & 0x8 else '')))
 
@@ -720,16 +724,15 @@ def show_tree(block_size, data, rev, trunk, weight, *,
                 '%-22s%s' % (
                     '%04x %08x %07x' % (tag, 0xffffffff & id, size),
                     '  %s' % ' '.join(
-                            '%08x' % struct.unpack('<I',
-                                data[j+delta+i*4:j+delta+min(i*4+4,size)]
-                                    .ljust(4, b'\0'))
+                            '%08x' % fromle32(
+                                data[j+d+i*4:j+d+min(i*4+4,size)])
                             for i in range(min(m.ceil(size/4), 3)))[:23]
                         if not args.get('no_truncate')
                             and not tag & 0x8 else '')))
 
         # show on-disk encoding of tags
         if args.get('raw'):
-            for o, line in enumerate(xxd(data[j:j+delta])):
+            for o, line in enumerate(xxd(data[j:j+d])):
                 print('%8s: %*s%*s %s' % (
                     '%04x' % (j + o*16),
                     tree_width, '',
@@ -737,16 +740,16 @@ def show_tree(block_size, data, rev, trunk, weight, *,
                     line))
         if args.get('raw') or args.get('no_truncate'):
             if not tag & 0x8:
-                for o, line in enumerate(xxd(data[j+delta:j+delta+size])):
+                for o, line in enumerate(xxd(data[j+d:j+d+size])):
                     print('%8s: %*s%*s %s' % (
-                        '%04x' % (j+delta + o*16),
+                        '%04x' % (j+d + o*16),
                         tree_width, '',
                         w_width, '',
                         line))
 
 
-def main(disk, block_size=None, block1=0, block2=None, *,
-        limit=None,
+def main(disk, block1=0, block2=None, *,
+        block_size=None,
         trunk=None,
         color='auto',
         **args):
@@ -764,13 +767,13 @@ def main(disk, block_size=None, block1=0, block2=None, *,
             f.seek(0, os.SEEK_END)
             block_size = f.tell()
 
-        # blocks may also encode limits
+        # blocks may also encode trunks 
         blocks = [
             block[0] if isinstance(block, tuple) else block
             for block in [block1, block2]
             if block is not None]
-        limits = [
-            limit if limit is not None
+        trunks = [
+            trunk if trunk is not None
                 else block[1] if isinstance(block, tuple)
                 else None
             for block in [block1, block2]
@@ -778,68 +781,82 @@ def main(disk, block_size=None, block1=0, block2=None, *,
 
         # read each block
         datas = []
-        for block, limit in zip(blocks, limits):
+        for block in blocks:
             f.seek(block * block_size)
-            datas.append(f.read(limit if limit is not None else block_size))
+            datas.append(f.read(block_size))
 
     # first figure out which block as the most recent revision
-    def fetch(data):
-        rev, = struct.unpack('<I', data[0:4].ljust(4, b'\0'))
-        crc = crc32c(data[0:4])
+    def fetch(data, trunk):
+        rev = fromle32(data[0:4])
+        crc = 0
+        crc_ = crc32c(data[0:4])
         off = 0
         j_ = 4
-        trunk = None
-        trunk_ = None
+        trunk_ = 0
+        trunk__ = 0
         weight = 0
         lower_, upper_ = 0, 0
         weight_ = 0
         wastrunk = False
-        while j_ < len(data):
-            v, tag, w, size, delta = fromtag(data[j_:])
-            if v != (popc(crc) & 1):
+        trunkoff = None 
+        while j_ < len(data) and (not trunk or off <= trunk):
+            v, tag, w, size, d = fromtag(data[j_:])
+            if v != (popc(crc_) & 1):
+                break
+            crc_ = crc32c(data[j_:j_+d], crc_)
+            j_ += d
+            if not tag & 0x8 and j_ + size > len(data):
                 break
-            crc = crc32c(data[j_:j_+delta], crc)
-            j_ += delta
-
-            # find trunk
-            if not wastrunk and (tag & 0xc) != 0x4:
-                trunk_ = j_ - delta
-                lower_, upper_ = 0, 0
-            wastrunk = not not tag & 0x8
-
-            # keep track of weight
-            if tag & 0x8:
-                if tag & 0x4:
-                    upper_ += w
-                else:
-                    lower_ += w
-            elif (tag & 0xc) == 0x0:
-                weight_ = lower_+upper_+w
 
             # take care of crcs
             if not tag & 0x8:
                 if (tag & 0xf00f) != TAG_CRC:
-                    crc = crc32c(data[j_:j_+size], crc)
+                    crc_ = crc32c(data[j_:j_+size], crc_)
                 # found a crc?
                 else:
-                    crc_, = struct.unpack('<I', data[j_:j_+4].ljust(4, b'\0'))
-                    if crc != crc_:
+                    crc__ = fromle32(data[j_:j_+4])
+                    if crc_ != crc__:
                         break
                     # commit what we have
-                    off = j_ + size
-                    trunk = trunk_
+                    off = trunkoff if trunkoff else j_ + size
+                    crc = crc_
+                    trunk_ = trunk__
                     weight = weight_
+
+            # evaluate trunks
+            if (tag & 0xc) != 0x4 and (
+                    not trunk or trunk >= j_-d or wastrunk):
+                # new trunk?
+                if not wastrunk:
+                    trunk__ = j_-d
+                    lower_, upper_ = 0, 0
+                    wastrunk = True
+
+                # keep track of weight
+                if tag & 0x8:
+                    if tag & 0x4:
+                        upper_ += w
+                    else:
+                        lower_ += w
+                else:
+                    weight_ = lower_+upper_+w
+                    wastrunk = False
+                    # keep track of off for best matching trunk
+                    if trunk and j_ + size > trunk:
+                        trunkoff = j_ + size
+
+            if not tag & 0x8:
                 j_ += size
 
-        return rev, off, trunk, weight
+        return rev, off, trunk_, weight
 
-    revs, offs, trunks, weights = [], [], [], []
+    revs, offs, trunks_, weights = [], [], [], []
     i = 0
-    for data in datas:
-        rev, off, trunk_, weight = fetch(data)
+    for data, trunk in zip(datas, trunks):
+        rev, off, trunk_, weight = fetch(data, trunk)
         revs.append(rev)
         offs.append(off)
-        trunks.append(trunk_)
+        trunks_.append(trunk_)
         weights.append(weight)
 
         # compare with sequence arithmetic
@@ -847,25 +864,21 @@ def main(disk, block_size=None, block1=0, block2=None, *,
             i = len(revs)-1
 
     # print contents of the winning metadata block
-    block, limit, data, rev, off, trunk, weight = (
-        blocks[i], limits[i], datas[i], revs[i], offs[i],
-        trunk if trunk is not None else trunks[i],
-        weights[i])
+    block, data, rev, off, trunk, weight = (
+        blocks[i], datas[i], revs[i], offs[i], trunks_[i], weights[i])
 
-    print('rbyd 0x%x%s, rev %d, size %d, weight %d%s' % (
-        block, '.%x' % limit if limit is not None else '',
-        rev, off, weight,
-        ' (was 0x%x%s, %d, %d, %d)' % (
-            blocks[~i], '.%x' % limits[~i] if limits[~i] is not None else '',
-            revs[~i], offs[~i], weights[~i])
+    print('rbyd 0x%x.%x, rev %d, size %d, weight %d%s' % (
+        block, trunk, rev, off, weight,
+        ' (was 0x%x.%x, %d, %d, %d)' % (
+            blocks[~i], trunks_[~i], revs[~i], offs[~i], weights[~i])
             if len(blocks) > 1 else ''))
 
     if args.get('log'):
-        show_log(block_size, data, rev, off, weight,
+        show_log(data, block_size, rev, off, weight,
             color=color,
             **args)
     else:
-        show_tree(block_size, data, rev, trunk, weight,
+        show_tree(data, block_size, rev, trunk, weight,
             color=color,
             **args)
 
@@ -885,21 +898,17 @@ if __name__ == "__main__":
     parser.add_argument(
         'block1',
         nargs='?',
-        type=blocklim,
+        type=rbydaddr,
         help="Block address of the first metadata block.")
     parser.add_argument(
         'block2',
         nargs='?',
-        type=blocklim,
+        type=rbydaddr,
         help="Block address of the second metadata block.")
     parser.add_argument(
         '-B', '--block-size',
         type=lambda x: int(x, 0),
         help="Block size in bytes.")
-    parser.add_argument(
-        '-L', '--limit',
-        type=lambda x: int(x, 0),
-        help="Use this offset as the rbyd limit.")
     parser.add_argument(
         '--trunk',
         type=lambda x: int(x, 0),
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index 61ea70a6..515dd561 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -6,6 +6,7 @@ defines.LOOKAHEAD_SIZE = 'BLOCK_COUNT / 8'
 
 # test an empty tree
 [cases.test_btree_zero]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -20,12 +21,11 @@ code = '''
 
     // create an empty tree
     lfsr_btree_t btree = LFSR_BTREE_NULL;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 0);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 0);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -35,11 +35,12 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 # test an inlined tree
 [cases.test_btree_one]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -55,12 +56,11 @@ code = '''
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL;
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 1);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -70,7 +70,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -78,11 +78,12 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 # test a single-rbyd tree
 [cases.test_btree_two]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -99,12 +100,11 @@ code = '''
     lfsr_btree_t btree = LFSR_BTREE_NULL;
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
     lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "b", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 2);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -114,7 +114,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -122,7 +122,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -130,10 +130,11 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_two_backwards]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -150,12 +151,11 @@ code = '''
     lfsr_btree_t btree = LFSR_BTREE_NULL;
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "b", 1) => 0;
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 2);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -165,7 +165,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -173,7 +173,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -181,11 +181,12 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 # still a single-rbyd tree, just making sure it works
 [cases.test_btree_three]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -203,12 +204,11 @@ code = '''
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
     lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "b", 1) => 0;
     lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_INLINED, 1, "c", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 3);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -218,7 +218,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -226,7 +226,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -234,7 +234,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 2);
     assert(weight_ == 1);
@@ -242,10 +242,11 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 3,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_three_backwards]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -263,12 +264,11 @@ code = '''
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "c", 1) => 0;
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "b", 1) => 0;
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 3);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -278,7 +278,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -286,7 +286,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -294,7 +294,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 2);
     assert(weight_ == 1);
@@ -302,13 +302,14 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 3,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 # try larger trees, when exactly a tree splits depends on the disk geometry, so
 # we don't really have a better way of testing multi-rbyd trees
 [cases.test_btree_push]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -328,12 +329,11 @@ code = '''
         lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_INLINED, 1,
                 &alphas[i % 26], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -344,7 +344,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, i,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i);
         assert(weight_ == 1);
@@ -354,11 +354,12 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, N,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_push_backwards]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -378,12 +379,11 @@ code = '''
         lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1,
                 &alphas[(N-1-i) % 26], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -394,7 +394,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, i,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i);
         assert(weight_ == 1);
@@ -404,11 +404,12 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, N,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_push_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 10
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -471,12 +472,11 @@ code = '''
             printf("%c", sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
-        assert(btree.weight == sim_size);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
+        assert(lfsr_btree_weight(&btree) == sim_size);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -485,7 +485,7 @@ code = '''
         for (lfs_size_t i = 0; i < sim_size; i++) {
             lfsr_btree_get(&lfs, &btree, i,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == i);
             assert(weight_ == 1);
@@ -495,7 +495,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, sim_size,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -506,6 +506,7 @@ code = '''
 [cases.test_btree_push_sparse]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.W = 5
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -525,12 +526,11 @@ code = '''
         lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_INLINED, W,
                 &alphas[i % 26], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N*W);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N*W);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -541,7 +541,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, i*W+W-1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i*W+W-1);
         assert(weight_ == W);
@@ -551,14 +551,14 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, N*W,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     id_ = -1;
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, id_+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i*W+W-1);
         assert(weight_ == W);
@@ -566,12 +566,13 @@ code = '''
     }
     lfsr_btree_get(&lfs, &btree, id_+1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_push_sparse_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.W = 5
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 10
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -654,17 +655,16 @@ code = '''
                     sim_weights[i], sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
 
         lfs_size_t total_weight = 0;
         for (lfs_size_t j = 0; j < sim_size; j++) {
             total_weight += sim_weights[j];
         }
-        assert(btree.weight == total_weight);
+        assert(lfsr_btree_weight(&btree) == total_weight);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -679,7 +679,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -689,7 +689,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, total_weight,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // also test that we can traverse the tree without prior knowledge
         id_ = -1;
@@ -702,7 +702,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, id_+1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -710,7 +710,7 @@ code = '''
         }
         lfsr_btree_get(&lfs, &btree, id_+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -722,6 +722,7 @@ code = '''
 
 # try some small trees for easy corner cases first
 [cases.test_btree_update_one]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -739,12 +740,11 @@ code = '''
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
     // update the tree
     lfsr_btree_update(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "A", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 1);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -754,7 +754,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -762,10 +762,11 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update_two]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -785,12 +786,11 @@ code = '''
     // update the tree
     lfsr_btree_update(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "A", 1) => 0;
     lfsr_btree_update(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "B", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 2);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -800,7 +800,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -808,7 +808,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -816,10 +816,11 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update_three]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -841,12 +842,11 @@ code = '''
     lfsr_btree_update(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "A", 1) => 0;
     lfsr_btree_update(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "B", 1) => 0;
     lfsr_btree_update(&lfs, &btree, 2, LFSR_TAG_INLINED, 1, "C", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 3);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -856,7 +856,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -864,7 +864,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -872,7 +872,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 2);
     assert(weight_ == 1);
@@ -880,11 +880,12 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 3,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -910,12 +911,11 @@ code = '''
         lfsr_btree_update(&lfs, &btree, i, LFSR_TAG_INLINED, 1,
                 &uppers[i % 26], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -926,7 +926,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, i,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i);
         assert(weight_ == 1);
@@ -936,11 +936,12 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, N,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 10
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -1007,12 +1008,11 @@ code = '''
             printf("%c", sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
-        assert(btree.weight == N);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
+        assert(lfsr_btree_weight(&btree) == N);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -1021,7 +1021,7 @@ code = '''
         for (lfs_size_t i = 0; i < N; i++) {
             lfsr_btree_get(&lfs, &btree, i,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == i);
             assert(weight_ == 1);
@@ -1031,7 +1031,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, N,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -1041,6 +1041,7 @@ code = '''
 [cases.test_btree_update_sparse]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.W = 5
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -1066,12 +1067,11 @@ code = '''
         lfsr_btree_update(&lfs, &btree, i*W+W-1, LFSR_TAG_INLINED, W,
                 &uppers[i % 26], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N*W);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N*W);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -1082,7 +1082,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, i*W+W-1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i*W+W-1);
         assert(weight_ == W);
@@ -1092,14 +1092,14 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, N*W,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     id_ = -1;
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, id_+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i*W+W-1);
         assert(weight_ == W);
@@ -1107,12 +1107,13 @@ code = '''
     }
     lfsr_btree_get(&lfs, &btree, id_+1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_update_sparse_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.W = 5
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 10
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -1198,17 +1199,16 @@ code = '''
                     sim_weights[i], sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
 
         lfs_size_t total_weight = 0;
         for (lfs_size_t j = 0; j < N; j++) {
             total_weight += sim_weights[j];
         }
-        assert(btree.weight == total_weight);
+        assert(lfsr_btree_weight(&btree) == total_weight);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -1223,7 +1223,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -1233,7 +1233,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, total_weight,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // also test that we can traverse the tree without prior knowledge
         id_ = -1;
@@ -1246,7 +1246,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, id_+1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -1254,7 +1254,7 @@ code = '''
         }
         lfsr_btree_get(&lfs, &btree, id_+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -1267,6 +1267,7 @@ code = '''
 # try some corner cases first, these are actually pretty tricky since we
 # need to recognize when to collapse back into an inlined tree
 [cases.test_btree_pop_one]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -1284,12 +1285,11 @@ code = '''
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
     // pop!
     lfsr_btree_pop(&lfs, &btree, 0) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 0);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 0);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -1299,21 +1299,20 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "A", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 1);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -1321,10 +1320,11 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_two]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -1343,12 +1343,11 @@ code = '''
     lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "b", 1) => 0;
     // pop!
     lfsr_btree_pop(&lfs, &btree, 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 1);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -1358,7 +1357,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -1366,21 +1365,20 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
     lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "B", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 2);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -1388,7 +1386,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -1396,10 +1394,11 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_two_other]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -1418,12 +1417,11 @@ code = '''
     lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "b", 1) => 0;
     // pop!
     lfsr_btree_pop(&lfs, &btree, 0) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 1);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -1433,7 +1431,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -1441,21 +1439,20 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "A", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 2);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -1463,7 +1460,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -1471,10 +1468,11 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_three]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -1494,12 +1492,11 @@ code = '''
     lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_INLINED, 1, "c", 1) => 0;
     // pop!
     lfsr_btree_pop(&lfs, &btree, 2) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 2);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try looking up tags
     uint8_t buffer[4];
@@ -1509,7 +1506,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -1517,7 +1514,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -1525,21 +1522,20 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
     lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_INLINED, 1, "C", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 3);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try looking up tags
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -1547,7 +1543,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 1);
     assert(weight_ == 1);
@@ -1555,7 +1551,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 2,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 2);
     assert(weight_ == 1);
@@ -1563,12 +1559,13 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 3,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.REMAINING = [64, 2, 1, 0]
+defines.VALIDATE = [1, 0]
 if = 'N > REMAINING'
 in = 'lfs.c'
 code = '''
@@ -1594,12 +1591,11 @@ code = '''
         lfsr_btree_pop(&lfs, &btree, N-1-i) => 0;
     }
 
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == REMAINING);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == REMAINING);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -1610,7 +1606,7 @@ code = '''
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_get(&lfs, &btree, i,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i);
         assert(weight_ == 1);
@@ -1620,7 +1616,7 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, REMAINING,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // try recovering
     lfsr_btree_push(&lfs, &btree, REMAINING, LFSR_TAG_INLINED, 1,
@@ -1629,7 +1625,7 @@ code = '''
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_get(&lfs, &btree, i,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i);
         assert(weight_ == 1);
@@ -1638,7 +1634,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, REMAINING,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == REMAINING);
     assert(weight_ == 1);
@@ -1646,12 +1642,13 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, REMAINING+1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_backwards]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.REMAINING = [64, 2, 1, 0]
+defines.VALIDATE = [1, 0]
 if = 'N > REMAINING'
 in = 'lfs.c'
 code = '''
@@ -1677,12 +1674,11 @@ code = '''
         lfsr_btree_pop(&lfs, &btree, 0) => 0;
     }
 
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == REMAINING);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == REMAINING);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -1693,7 +1689,7 @@ code = '''
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_get(&lfs, &btree, i,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i);
         assert(weight_ == 1);
@@ -1703,7 +1699,7 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, REMAINING,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // try recovering
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1,
@@ -1711,7 +1707,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, 0,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == 0);
     assert(weight_ == 1);
@@ -1720,7 +1716,7 @@ code = '''
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_get(&lfs, &btree, i+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i+1);
         assert(weight_ == 1);
@@ -1729,12 +1725,13 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, REMAINING+1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.REMAINING = [64, 2, 1, 0]
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 10
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -1802,12 +1799,11 @@ code = '''
             printf("%c", sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
-        assert(btree.weight == sim_size);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
+        assert(lfsr_btree_weight(&btree) == sim_size);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -1816,7 +1812,7 @@ code = '''
         for (lfs_size_t i = 0; i < sim_size; i++) {
             lfsr_btree_get(&lfs, &btree, i,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == i);
             assert(weight_ == 1);
@@ -1826,7 +1822,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, sim_size,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -1836,6 +1832,7 @@ code = '''
 [cases.test_btree_pop_sparse]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.REMAINING = [64, 2, 1, 0]
+defines.VALIDATE = [1, 0]
 defines.W = 5
 if = 'N > REMAINING'
 in = 'lfs.c'
@@ -1862,12 +1859,11 @@ code = '''
         lfsr_btree_pop(&lfs, &btree, (N-1-i)*W+W-1) => 0;
     }
 
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == REMAINING*W);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == REMAINING*W);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -1878,7 +1874,7 @@ code = '''
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_get(&lfs, &btree, i*W+W-1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i*W+W-1);
         assert(weight_ == W);
@@ -1888,7 +1884,7 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, REMAINING*W+W-1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // try recovering
     lfsr_btree_push(&lfs, &btree, REMAINING*W, LFSR_TAG_INLINED, W,
@@ -1897,7 +1893,7 @@ code = '''
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_get(&lfs, &btree, i*W+W-1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i*W+W-1);
         assert(weight_ == W);
@@ -1906,7 +1902,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, REMAINING*W+W-1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == REMAINING*W+W-1);
     assert(weight_ == W);
@@ -1914,14 +1910,14 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, (REMAINING+1)*W+W-1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
     // also test that we can traverse the tree without prior knowledge
     id_ = -1;
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_get(&lfs, &btree, id_+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i*W+W-1);
         assert(weight_ == W);
@@ -1930,7 +1926,7 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, id_+1,
             &id_, &tag_, &weight_,
-            buffer, 4) => 1;
+            buffer, 4, VALIDATE) => 1;
     assert(tag_ == LFSR_TAG_INLINED);
     assert(id_ == REMAINING*W+W-1);
     assert(weight_ == W);
@@ -1938,13 +1934,14 @@ code = '''
 
     lfsr_btree_get(&lfs, &btree, id_+1,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_pop_sparse_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.REMAINING = [64, 2, 1, 0]
 defines.W = 5
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 10
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -2040,17 +2037,16 @@ code = '''
                     sim_weights[i], sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
 
         lfs_size_t total_weight = 0;
         for (lfs_size_t j = 0; j < sim_size; j++) {
             total_weight += sim_weights[j];
         }
-        assert(btree.weight == total_weight);
+        assert(lfsr_btree_weight(&btree) == total_weight);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -2065,7 +2061,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -2075,7 +2071,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, total_weight,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // also test that we can traverse the tree without prior knowledge
         id_ = -1;
@@ -2088,7 +2084,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, id_+1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -2096,7 +2092,7 @@ code = '''
         }
         lfsr_btree_get(&lfs, &btree, id_+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -2107,6 +2103,7 @@ code = '''
 # test btree splits
 [cases.test_btree_split]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -2129,12 +2126,11 @@ code = '''
                 LFSR_TAG_INLINED, 1, &alphas[(i-1) % 26], 1,
                 LFSR_TAG_INLINED, 1, &alphas[(i-0) % 26], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -2145,7 +2141,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, i,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i);
         assert(weight_ == 1);
@@ -2155,11 +2151,12 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, N,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_split_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 10
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -2228,12 +2225,11 @@ code = '''
             printf("%c", sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
-        assert(btree.weight == sim_size);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
+        assert(lfsr_btree_weight(&btree) == sim_size);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -2242,7 +2238,7 @@ code = '''
         for (lfs_size_t i = 0; i < sim_size; i++) {
             lfsr_btree_get(&lfs, &btree, i,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == i);
             assert(weight_ == 1);
@@ -2252,7 +2248,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, sim_size,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -2263,6 +2259,7 @@ code = '''
 [cases.test_btree_split_sparse]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.W = 5
+defines.VALIDATE = [1, 0]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -2285,12 +2282,11 @@ code = '''
                 LFSR_TAG_INLINED, W, &alphas[(i-1) % 26], 1,
                 LFSR_TAG_INLINED, W, &alphas[(i-0) % 26], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N*W);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N*W);
 
     // check that the elements are in the tree
     uint8_t buffer[4];
@@ -2301,7 +2297,7 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_btree_get(&lfs, &btree, i*W+W-1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => 1;
+                buffer, 4, VALIDATE) => 1;
         assert(tag_ == LFSR_TAG_INLINED);
         assert(id_ == i*W+W-1);
         assert(weight_ == W);
@@ -2311,12 +2307,13 @@ code = '''
     // and check that we can't lookup elements that aren't in the tree
     lfsr_btree_get(&lfs, &btree, N*W,
             &id_, &tag_, &weight_,
-            buffer, 4) => LFS_ERR_NOENT;
+            buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_split_sparse_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.W = 5
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 10
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -2409,17 +2406,16 @@ code = '''
                     sim_weights[i], sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
 
         lfs_size_t total_weight = 0;
         for (lfs_size_t j = 0; j < sim_size; j++) {
             total_weight += sim_weights[j];
         }
-        assert(btree.weight == total_weight);
+        assert(lfsr_btree_weight(&btree) == total_weight);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -2434,7 +2430,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -2444,7 +2440,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, total_weight,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // also test that we can traverse the tree without prior knowledge
         id_ = -1;
@@ -2457,7 +2453,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, id_+1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -2465,7 +2461,7 @@ code = '''
         }
         lfsr_btree_get(&lfs, &btree, id_+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -2477,6 +2473,7 @@ code = '''
 # Some more general fuzz testing
 [cases.test_btree_general_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 100
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -2561,12 +2558,11 @@ code = '''
             printf("%c", sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
-        assert(btree.weight == sim_size);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
+        assert(lfsr_btree_weight(&btree) == sim_size);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -2575,7 +2571,7 @@ code = '''
         for (lfs_size_t i = 0; i < sim_size; i++) {
             lfsr_btree_get(&lfs, &btree, i,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == i);
             assert(weight_ == 1);
@@ -2585,7 +2581,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, sim_size,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -2595,6 +2591,7 @@ code = '''
 [cases.test_btree_general_sparse_fuzz]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.W = 5
+defines.VALIDATE = [1, 0]
 defines.SAMPLES = 100
 # -1 => all pseudo-random seeds
 #  n => reproduce a specific seed
@@ -2703,17 +2700,16 @@ code = '''
                     sim_weights[i], sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
 
         lfs_size_t total_weight = 0;
         for (lfs_size_t j = 0; j < sim_size; j++) {
             total_weight += sim_weights[j];
         }
-        assert(btree.weight == total_weight);
+        assert(lfsr_btree_weight(&btree) == total_weight);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -2728,7 +2724,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -2738,7 +2734,7 @@ code = '''
         // and no extra elements
         lfsr_btree_get(&lfs, &btree, total_weight,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // also test that we can traverse the tree without prior knowledge
         id_ = -1;
@@ -2751,7 +2747,7 @@ code = '''
 
             lfsr_btree_get(&lfs, &btree, id_+1,
                     &id_, &tag_, &weight_,
-                    buffer, 4) => 1;
+                    buffer, 4, VALIDATE) => 1;
             assert(tag_ == LFSR_TAG_INLINED);
             assert(id_ == weighted_id+sim_weights[i]-1);
             assert(weight_ == sim_weights[i]);
@@ -2759,7 +2755,7 @@ code = '''
         }
         lfsr_btree_get(&lfs, &btree, id_+1,
                 &id_, &tag_, &weight_,
-                buffer, 4) => LFS_ERR_NOENT;
+                buffer, 4, VALIDATE) => LFS_ERR_NOENT;
 
         // clean up sim
         free(sim);
@@ -2768,6 +2764,38 @@ code = '''
 
 
 # test key-value btrees
+[cases.test_btree_find_zero]
+in = 'lfs.c'
+code = '''
+    lfs_t lfs;
+    lfs_init(&lfs, cfg) => 0;
+    // create free lookahead
+    memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
+    lfs.free.off = 0;
+    lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
+            lfs.cfg->block_count);
+    lfs.free.i = 0;
+    lfs_alloc_ack(&lfs);
+
+    // create a zero-entry tree
+    lfsr_btree_t btree = LFSR_BTREE_NULL;
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 0);
+
+    // try to find tags
+    uint8_t buffer[4];
+    lfsr_tag_t tag_;
+    lfs_size_t id_;
+    lfs_size_t weight_;
+
+    lfsr_btree_find(&lfs, &btree, "aaa", 3,
+            &id_, &tag_, &weight_,
+            buffer, 4) => LFS_ERR_NOENT;
+'''
+
 [cases.test_btree_find_one]
 in = 'lfs.c'
 code = '''
@@ -2784,12 +2812,11 @@ code = '''
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL;
     lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "0", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 1);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 1);
 
     // try to find tags
     uint8_t buffer[4];
@@ -2833,12 +2860,11 @@ code = '''
     lfsr_btree_split(&lfs, &btree, 0, "aab", 3,
             LFSR_TAG_INLINED, 1, "0", 1,
             LFSR_TAG_INLINED, 1, "1", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 2);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 2);
 
     // try to find tags
     uint8_t buffer[4];
@@ -2893,12 +2919,11 @@ code = '''
     lfsr_btree_split(&lfs, &btree, 1, "aac", 3,
             LFSR_TAG_INLINED, 1, "1", 1,
             LFSR_TAG_INLINED, 1, "2", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 3);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try to find tags
     uint8_t buffer[4];
@@ -2961,12 +2986,11 @@ code = '''
     lfsr_btree_split(&lfs, &btree, 0, "aab", 3,
             LFSR_TAG_INLINED, 1, "0", 1,
             LFSR_TAG_INLINED, 1, "1", 1) => 0;
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == 3);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == 3);
 
     // try to find tags
     uint8_t buffer[4];
@@ -3035,12 +3059,11 @@ code = '''
                 LFSR_TAG_INLINED, 1, &nums[(i-1) % 10], 1,
                 LFSR_TAG_INLINED, 1, &nums[(i-0) % 10], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N);
 
     // try to find tags
     uint8_t buffer[4];
@@ -3151,12 +3174,11 @@ code = '''
             printf("%.3s=%c", sim_names[i], sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
-        assert(btree.weight == sim_size);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
+        assert(lfsr_btree_weight(&btree) == sim_size);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -3208,12 +3230,11 @@ code = '''
                 LFSR_TAG_INLINED, W, &nums[(i-1) % 10], 1,
                 LFSR_TAG_INLINED, W, &nums[(i-0) % 10], 1) => 0;
     }
-    printf("btree: 0x%x.%x 0x%x w%d\n",
-        btree.u.trunk.block,
-        btree.u.trunk.limit,
-        btree.tag,
-        btree.weight);
-    assert(btree.weight == N*W);
+    printf("btree: w%d 0x%x.%x\n",
+        btree.weight,
+        btree.root.block,
+        btree.root.trunk);
+    assert(lfsr_btree_weight(&btree) == N*W);
 
     // try to find tags
     uint8_t buffer[4];
@@ -3352,17 +3373,16 @@ code = '''
                     sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
 
         lfs_size_t total_weight = 0;
         for (lfs_size_t j = 0; j < sim_size; j++) {
             total_weight += sim_weights[j];
         }
-        assert(btree.weight == total_weight);
+        assert(lfsr_btree_weight(&btree) == total_weight);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -3524,12 +3544,11 @@ code = '''
             printf("%.3s=%c", sim_names[i], sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
-        assert(btree.weight == sim_size);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
+        assert(lfsr_btree_weight(&btree) == sim_size);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
@@ -3720,17 +3739,16 @@ code = '''
                     sim[i]);
         }
         printf("]\n");
-        printf("btree: 0x%x.%x 0x%x w%d\n",
-            btree.u.trunk.block,
-            btree.u.trunk.limit,
-            btree.tag,
-            btree.weight);
+        printf("btree: w%d 0x%x.%x\n",
+            btree.weight,
+            btree.root.block,
+            btree.root.trunk);
 
         lfs_size_t total_weight = 0;
         for (lfs_size_t j = 0; j < sim_size; j++) {
             total_weight += sim_weights[j];
         }
-        assert(btree.weight == total_weight);
+        assert(lfsr_btree_weight(&btree) == total_weight);
 
         uint8_t buffer[4];
         lfsr_tag_t tag_;
diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml
index 166c68ab..9eada54e 100644
--- a/tests/test_rbyd.toml
+++ b/tests/test_rbyd.toml
@@ -33,14 +33,14 @@ code = '''
     rbyd = init_rbyd;
     lfs_bd_erase(&lfs, rbyd.block) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, NULL, 0) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
 
     // commit with one attribute
     rbyd = init_rbyd;
     lfs_bd_erase(&lfs, rbyd.block) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
 
     // commit with two attributes
     rbyd = init_rbyd;
@@ -48,7 +48,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
 '''
 
 [cases.test_rbyd_multi_commit]
@@ -71,14 +71,14 @@ code = '''
     rbyd = init_rbyd;
     lfs_bd_erase(&lfs, rbyd.block) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, NULL, 0) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
 
     // commit with one attribute
     rbyd = init_rbyd;
     lfs_bd_erase(&lfs, rbyd.block) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
 
     // commit with two attributes
     rbyd = init_rbyd;
@@ -87,7 +87,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
 '''
 
 [cases.test_rbyd_commit_fetch_commit]
@@ -111,12 +111,12 @@ code = '''
     lfs_bd_erase(&lfs, rbyd.block) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
 
     // commit with the second attribute
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
 '''
 
 # [cases.test_rbyd_fetchmatch]
@@ -152,7 +152,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
@@ -170,7 +170,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -199,7 +199,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -233,7 +233,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -276,7 +276,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
@@ -294,7 +294,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -324,7 +324,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -359,7 +359,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -399,7 +399,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
@@ -415,7 +415,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -436,7 +436,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 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)
@@ -457,7 +457,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 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)
@@ -491,7 +491,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
@@ -507,7 +507,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -529,7 +529,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 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)
@@ -551,7 +551,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 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)
@@ -590,7 +590,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -612,7 +612,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -656,7 +656,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -679,7 +679,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -725,7 +725,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4),
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -755,7 +755,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -807,7 +807,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4),
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -838,7 +838,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -869,7 +869,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -900,7 +900,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -954,7 +954,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4),
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -992,7 +992,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1030,7 +1030,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1068,7 +1068,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1127,7 +1127,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4),
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1165,7 +1165,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4),
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1203,7 +1203,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4),
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1241,7 +1241,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4),
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1303,7 +1303,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4),
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1344,7 +1344,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4),
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1383,7 +1383,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1422,7 +1422,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1486,7 +1486,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4),
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1534,7 +1534,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4),
             LFSR_ATTR(-1, UATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1580,7 +1580,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1626,7 +1626,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1696,7 +1696,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4),
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1745,7 +1745,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1794,7 +1794,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1866,7 +1866,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, "\xee\xee\xee\xee", 4),
             LFSR_ATTR(-1, UATTR(6), 0, "\xff\xff\xff\xff", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1920,7 +1920,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(6), 0, "\xff\xff\xff\xff", 4),
             LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1974,7 +1974,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(6), 0, "\xff\xff\xff\xff", 4),
             LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2067,7 +2067,7 @@ code = '''
         lfs_bd_erase(&lfs, rbyd.block) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1),
                     &id_, &tag_, NULL, &off_, &size_) => 0;
@@ -2156,7 +2156,7 @@ code = '''
                         "\xaa\xaa\xaa\xaa", 4))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1),
                     &id_, &tag_, NULL, &off_, &size_) => 0;
@@ -2229,7 +2229,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2263,7 +2263,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2321,7 +2321,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2356,7 +2356,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2427,7 +2427,7 @@ code = '''
         lfs_bd_erase(&lfs, rbyd.block) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         // try traversing all tags
         tag_ = 0;
         id_ = -1;
@@ -2498,7 +2498,7 @@ code = '''
                         "\xaa\xaa\xaa\xaa", 4))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         // try traversing all tags
         tag_ = 0;
         id_ = -1;
@@ -2595,7 +2595,7 @@ code = '''
         }
 
         // check that all tags have been updated
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1),
                     &id_, &tag_, NULL, &off_, &size_) => 0;
@@ -2681,7 +2681,7 @@ code = '''
 
     // check that we can still lookup all the tags
     prng = 42;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     for (lfs_size_t i = 0; i < count; i++) {
         uint8_t x
                 = (ORDER == 0) ? (uint8_t)i
@@ -2731,7 +2731,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
@@ -2759,7 +2759,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -2792,7 +2792,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -3189,7 +3189,7 @@ code = '''
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
     // one last fetch to make sure nothing was broken
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3426,7 +3426,7 @@ code = '''
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
     // one last fetch to make sure nothing was broken
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3484,7 +3484,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
@@ -3505,7 +3505,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
@@ -3526,7 +3526,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
@@ -3613,7 +3613,7 @@ code = '''
         }
 
         // check that all tags are now removed
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1),
                     &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
@@ -3624,7 +3624,7 @@ code = '''
                 LFSR_ATTR(-1, UATTR(1), 0,
                     "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
                 &id_, &tag_, NULL, &off_, &size_) => 0;
         assert(tag_ == LFSR_TAG_UATTR(1));
@@ -3832,7 +3832,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3850,7 +3850,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3870,7 +3870,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3893,7 +3893,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3918,7 +3918,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3943,7 +3943,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3981,7 +3981,7 @@ code = '''
             => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -4001,7 +4001,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4022,7 +4022,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4047,7 +4047,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4074,7 +4074,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4101,7 +4101,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4183,7 +4183,7 @@ code = '''
         lfs_bd_erase(&lfs, rbyd.block) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
@@ -4282,7 +4282,7 @@ code = '''
                     LFSR_ATTR(id, MKREG, +1, names[perm[j] % 6], 4))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd,
@@ -4359,7 +4359,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -4401,7 +4401,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -4468,7 +4468,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -4511,7 +4511,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -4602,7 +4602,7 @@ code = '''
         lfs_bd_erase(&lfs, rbyd.block) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
         // try traversing all tags
         tag_ = 0;
@@ -4692,7 +4692,7 @@ code = '''
                     LFSR_ATTR(id, MKREG, +1, names[perm[j] % 6], 4))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
         // try traversing all tags
         tag_ = 0;
@@ -4774,7 +4774,7 @@ code = '''
     lfs_ssize_t id_;
     lfs_off_t off_;
     lfs_size_t size_;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     for (uint16_t x = 0; x < rbyd.weight; x++) {
         lfsr_rbyd_lookup(&lfs, &rbyd, x, LFSR_TAG_REG,
                 &id_, &tag_, NULL, &off_, &size_) => 0;
@@ -4817,7 +4817,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4843,7 +4843,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4873,7 +4873,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4903,7 +4903,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4926,7 +4926,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4966,7 +4966,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5006,7 +5006,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5053,7 +5053,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xaa\xaa", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5082,7 +5082,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5115,7 +5115,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xbb\xbb", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5150,7 +5150,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5173,7 +5173,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5218,7 +5218,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5263,7 +5263,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2;
     assert(memcmp(buffer, "\xcc\xcc", 2) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5357,7 +5357,7 @@ code = '''
         lfs_bd_erase(&lfs, rbyd.block) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, (1+M)*N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
@@ -5469,7 +5469,7 @@ code = '''
             }
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
@@ -5567,7 +5567,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -5639,7 +5639,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -5738,7 +5738,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -5813,7 +5813,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, NULL, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -5924,7 +5924,7 @@ code = '''
         lfs_bd_erase(&lfs, rbyd.block) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, (1+M)*N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
 
         // try traversing all tags
@@ -6033,7 +6033,7 @@ code = '''
             }
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
 
         // try traversing all tags
@@ -6157,7 +6157,7 @@ code = '''
         }
 
         // check that all tags have been updated
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
@@ -6484,7 +6484,7 @@ code = '''
         }
 
         // check that all tags have been removed
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
@@ -6592,7 +6592,7 @@ code = '''
     lfs_ssize_t id_;
     lfs_off_t off_;
     lfs_size_t size_;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     for (uint16_t x = 0; x < rbyd.weight; x++) {
         lfsr_rbyd_lookup(&lfs, &rbyd, x, LFSR_TAG_REG,
                 &id_, &tag_, NULL, &off_, &size_) => 0;
@@ -6690,7 +6690,7 @@ code = '''
         }
 
         // try looking up each tag
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd,
@@ -6836,7 +6836,7 @@ code = '''
         }
 
         // try looking up each tag
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd,
@@ -6949,7 +6949,7 @@ code = '''
     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_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -6969,7 +6969,7 @@ code = '''
     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_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
@@ -7085,7 +7085,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -7121,7 +7121,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -7164,7 +7164,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -7214,7 +7214,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -7264,7 +7264,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -7939,7 +7939,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -7958,7 +7958,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -7977,7 +7977,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -7998,7 +7998,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -8019,7 +8019,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -8055,7 +8055,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -8076,7 +8076,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -8097,7 +8097,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -8121,7 +8121,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -8145,7 +8145,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -8247,7 +8247,7 @@ code = '''
         }
 
         // check that all tags are now removed
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == 0);
         lfsr_rbyd_get(&lfs, &rbyd,
                 LFSR_TAG_REG, 0, buffer, 4)
@@ -8258,7 +8258,7 @@ code = '''
                 LFSR_ATTR(0, MKREG, +1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0;
         assert(rbyd.weight == 1);
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == 1);
         lfsr_rbyd_get(&lfs, &rbyd,
                 0, LFSR_TAG_REG, buffer, 6)
@@ -8395,7 +8395,7 @@ code = '''
         }
 
         // check that all tags are now removed
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == 0);
         lfsr_rbyd_get(&lfs, &rbyd,
                 0, LFSR_TAG_REG, buffer, 4)
@@ -8410,7 +8410,7 @@ code = '''
         }
         assert(rbyd.weight == 1);
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == 1);
         lfsr_rbyd_get(&lfs, &rbyd,
                 0, LFSR_TAG_REG, buffer, 6)
@@ -8632,7 +8632,7 @@ code = '''
     assert(weight_ == 1);
     assert(size_ == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8657,7 +8657,7 @@ code = '''
     assert(weight_ == 2);
     assert(size_ == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8694,7 +8694,7 @@ code = '''
     assert(weight_ == 3);
     assert(size_ == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8743,7 +8743,7 @@ code = '''
     assert(weight_ == 4);
     assert(size_ == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8804,7 +8804,7 @@ code = '''
     assert(weight_ == 5);
     assert(size_ == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8906,7 +8906,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, &weight_, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -9013,7 +9013,7 @@ code = '''
                     LFSR_ATTR(id*W, MKREG, +W, names[perm[j] % 6], 4))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N*W);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG,
@@ -9101,7 +9101,7 @@ code = '''
                     LFSR_ATTR(id*W, MKREG, +W, names[perm[j] % 6], 4))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N*W);
         // try traversing all tags
         tag_ = 0;
@@ -9178,7 +9178,7 @@ code = '''
     assert(weight_ == 0);
     assert(size_ == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9254,7 +9254,7 @@ code = '''
     assert(weight_ == 0);
     assert(size_ == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9366,7 +9366,7 @@ code = '''
     assert(weight_ == 0);
     assert(size_ == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9514,7 +9514,7 @@ code = '''
     assert(weight_ == 0);
     assert(size_ == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9698,7 +9698,7 @@ code = '''
     assert(weight_ == 0);
     assert(size_ == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9947,7 +9947,7 @@ code = '''
     lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_),
             &id_, &tag_, &weight_, &off_, &size_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0,
             &id_, &tag_, &weight_, &off_, &size_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -10127,7 +10127,7 @@ code = '''
                         names[perm[j] % 6], 2))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N*W);
         lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
                 &id_, &tag_, &weight_, &off_, &size_) => 0;
@@ -10240,7 +10240,7 @@ code = '''
                         names[perm[j] % 6], 2))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0;
         assert(rbyd.weight == N*W);
         // try traversing all tags
         tag_ = 0;