From a511696bad841c8bf5e7f9c81c2d66dfcf8443bd Mon Sep 17 00:00:00 2001
From: Christopher Haster <geky@geky.net>
Date: Sun, 9 Apr 2023 02:21:02 -0500
Subject: [PATCH] Added ability to bypass rbyd fetch during B-tree lookups

This is an absurd optimization that stems from the observation that the
branch encoding for the inner-rbyds in a B-tree is enough information to
jump directly to the trunk of the rbyd without needing an lfsr_rbyd_fetch.

This results in a pretty ridiculous performance jump from O(m log_m(n/m))
to O(log(m) log_m(n/m)).

If the complexity analysis isn't impressive enough, look at some rough
benchmarking of read operations for 4KiB-block, 1K-entry B-trees:

   12KiB ^     ::  :. :: .: .: :. : .: :. : : .. : : . : .: : : :
         |    .:: .::.::.:: ::.::::::::::::.::::::::.::::::::::::.
         |    : :::':: ::'::'::':: :' :':: :'::::::::': ::::::': :
before   |  ::: ::' :' :' :: :' '' '  ' '' : : : '' ' ' '
         | :::            ''
         |:
      0B :'------------------------------------------------------>

  .17KiB ^               ............:::::::::::::::::::::::::::::
         |   .   .....:::::'''''''''  '         '          '
         |  .::::::::::::
after    |  :':''
         |.::
         .:'
      0B :------------------------------------------------------->
         0                                                      1K

In order for this to work, the branch encoding did need to be tweaked
slightly. Before it stored block+off, now it stores block+trunk where
"trunk" is the offset of the entry point into the rbyd tree. Both off
and trunk are enough info to know when to stop fetching, if necessary,
but trunk allows lookups to jump directly into the branches rbyd tree
without a fetch.

With the change to trunk, lfsr_rbyd_fetch has also be extended to allow
fetching of any internal trunks, not just the last trunk in the commit.
This is very useful for dbgrbyd.py, but doesn't currently have a use in
littlefs itself. But it's at least valuable to have the feature available
in case it does become useful.

Note that two cases still requires the slower O(m log_m(n/m)) lookup
with lfsr_rbyd_fetch:

1. Name lookups, since we currently use a linear-search O(m) to find names.

2. Validating B-tree rbyd's, which requires a linear fetch O(m) to
   validate the checksums. We will need to do this at least once
   after mount.

It's also worth mentioning this will likely have a large impact on B-tree
traversal speed. Which is huge as I am expecting B-tree traversal to be
the main bottleneck once garbage-collection (or its replacement) is
involved.
---
 lfs.c                 | 855 ++++++++++++++++++++++++------------------
 lfs.h                 |  60 ++-
 lfs_util.h            |   5 +
 scripts/dbgbtree.py   | 173 +++++----
 scripts/dbgrbyd.py    | 213 ++++++-----
 tests/test_btree.toml | 806 ++++++++++++++++++++-------------------
 tests/test_rbyd.toml  | 322 ++++++++--------
 7 files changed, 1304 insertions(+), 1130 deletions(-)

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;