diff --git a/lfs.c b/lfs.c
index 253cf510..b94f8aa0 100644
--- a/lfs.c
+++ b/lfs.c
@@ -2044,8 +2044,8 @@ static inline bool lfsr_rbyd_isfetched(const lfsr_rbyd_t *rbyd) {
 static inline int lfsr_rbyd_cmp(
         const lfsr_rbyd_t *a,
         const lfsr_rbyd_t *b) {
-    if (a->block != b->block) {
-        return a->block - b->block;
+    if (a->blocks[0] != b->blocks[0]) {
+        return a->blocks[0] - b->blocks[0];
     } else {
         return a->trunk - b->trunk;
     }
@@ -2055,13 +2055,13 @@ static inline int lfsr_rbyd_cmp(
 // allocate an rbyd block
 static int lfsr_rbyd_alloc(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
     *rbyd = (lfsr_rbyd_t){.weight=0, .trunk=0, .eoff=0, .cksum=0};
-    int err = lfs_alloc(lfs, &rbyd->block);
+    int err = lfs_alloc(lfs, &rbyd->blocks[0]);
     if (err) {
         return err;
     }
             
     // TODO should erase be implicit in alloc eventually?
-    err = lfsr_bd_erase(lfs, rbyd->block);
+    err = lfsr_bd_erase(lfs, rbyd->blocks[0]);
     if (err) {
         return err;
     }
@@ -2079,7 +2079,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
         return err;
     }
 
-    rbyd->block = block;
+    rbyd->blocks[0] = block;
     rbyd->eoff = 0;
     rbyd->trunk = 0;
 
@@ -2231,7 +2231,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
         // this failed most likely a previous prog was interrupted, we
         // need a new erase
         uint32_t ecksum_ = 0;
-        err = lfsr_bd_cksum(lfs, rbyd->block, rbyd->eoff, 0, ecksum.size,
+        err = lfsr_bd_cksum(lfs, rbyd->blocks[0], rbyd->eoff, 0, ecksum.size,
                 &ecksum_);
         if (err && err != LFS_ERR_CORRUPT) {
             return err;
@@ -2270,7 +2270,7 @@ static int lfsr_rbyd_fetchvalidate(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     if (rbyd->cksum != cksum) {
         LFS_ERROR("Found rbyd cksum mismatch rbyd 0x%"PRIx32".%"PRIx32", "
                 "cksum 0x%08"PRIx32" (!= 0x%08"PRIx32")",
-                rbyd->block, rbyd->trunk, rbyd->cksum, cksum);
+                rbyd->blocks[0], rbyd->trunk, rbyd->cksum, cksum);
         return LFS_ERR_CORRUPT;
     }
 
@@ -2310,7 +2310,7 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
         lfsr_rid_t weight;
         lfs_size_t jump;
         lfs_ssize_t d = lfsr_bd_readtag(lfs,
-                rbyd->block, branch, 0,
+                rbyd->blocks[0], branch, 0,
                 &alt, &weight, &jump, NULL);
         if (d < 0) {
             return d;
@@ -2353,7 +2353,7 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
                 *weight_ = upper - lower;
             }
             if (data_) {
-                *data_ = LFSR_DATA_DISK(rbyd->block, branch + d, jump);
+                *data_ = LFSR_DATA_DISK(rbyd->blocks[0], branch + d, jump);
             }
             return 0;
         }
@@ -2401,7 +2401,7 @@ static int lfsr_rbyd_appendrev(lfs_t *lfs, lfsr_rbyd_t *rbyd, uint32_t rev) {
     // intentionally allow the revision count to overflow
     uint8_t rev_buf[sizeof(uint32_t)];
     lfs_tole32_(rev, &rev_buf);
-    int err = lfsr_bd_prog(lfs, rbyd->block, rbyd->eoff,
+    int err = lfsr_bd_prog(lfs, rbyd->blocks[0], rbyd->eoff,
             &rev_buf, sizeof(uint32_t), &rbyd->cksum);
     if (err) {
         return err;
@@ -2426,7 +2426,7 @@ static int lfsr_rbyd_p_flush(lfs_t *lfs, lfsr_rbyd_t *rbyd,
             lfsr_rid_t weight = p_weights[3-1-i];
             lfs_size_t jump = rbyd->eoff - p_jumps[3-1-i];
 
-            lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff,
+            lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff,
                     alt, weight, jump,
                     &rbyd->cksum);
             if (d < 0) {
@@ -2652,7 +2652,7 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
         lfsr_rid_t weight;
         lfs_size_t jump;
         lfs_ssize_t d = lfsr_bd_readtag(lfs,
-                rbyd->block, branch, 0,
+                rbyd->blocks[0], branch, 0,
                 &alt, &weight, &jump, NULL);
         if (d < 0) {
             return d;
@@ -2990,7 +2990,7 @@ leaf:;
     //
     // note we always need a non-alt to terminate the trunk, otherwise we
     // can't find trunks during fetch
-    lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff,
+    lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff,
             // rm => null or shrubnull, otherwise strip off control bits
             (lfsr_tag_isrm(tag)
                 ? lfsr_tag_mode(lfsr_tag_shrubkey(tag))
@@ -3004,7 +3004,7 @@ leaf:;
     rbyd->eoff += d;
 
     // don't forget the data!
-    err = lfsr_bd_progdata(lfs, rbyd->block, rbyd->eoff, data,
+    err = lfsr_bd_progdata(lfs, rbyd->blocks[0], rbyd->eoff, data,
             &rbyd->cksum);
     if (err) {
         return err;
@@ -3064,7 +3064,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
         // read the leading byte in case we need to change the expected
         // value of the next tag's valid bit
         int err = lfsr_bd_read(lfs,
-                rbyd->block, aligned_eoff, lfs->cfg->prog_size,
+                rbyd->blocks[0], aligned_eoff, lfs->cfg->prog_size,
                 &perturb, 1);
         if (err && err != LFS_ERR_CORRUPT) {
             return err;
@@ -3073,7 +3073,8 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
         // find the expected ecksum, don't bother avoiding a reread of the
         // perturb byte, as it should still be in our cache
         lfsr_ecksum_t ecksum = {.size=lfs->cfg->prog_size, .cksum=0};
-        err = lfsr_bd_cksum(lfs, rbyd->block, aligned_eoff, lfs->cfg->prog_size,
+        err = lfsr_bd_cksum(lfs,
+                rbyd->blocks[0], aligned_eoff, lfs->cfg->prog_size,
                 lfs->cfg->prog_size,
                 &ecksum.cksum);
         if (err && err != LFS_ERR_CORRUPT) {
@@ -3082,7 +3083,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
 
         uint8_t ecksum_buf[LFSR_ECKSUM_DSIZE];
         lfsr_data_t ecksum_data = lfsr_data_fromecksum(&ecksum, ecksum_buf);
-        lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff,
+        lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff,
                 LFSR_TAG_ECKSUM, 0, lfsr_data_size(&ecksum_data),
                 &rbyd->cksum);
         if (d < 0) {
@@ -3090,7 +3091,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
         }
         rbyd->eoff += d;
 
-        err = lfsr_bd_progdata(lfs, rbyd->block, rbyd->eoff, ecksum_data,
+        err = lfsr_bd_progdata(lfs, rbyd->blocks[0], rbyd->eoff, ecksum_data,
                 &rbyd->cksum);
         if (err) {
             return err;
@@ -3135,7 +3136,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
     }
     lfs_tole32_(rbyd->cksum, &cksum_buf[2+1+5]);
 
-    int err = lfsr_bd_prog(lfs, rbyd->block, rbyd->eoff,
+    int err = lfsr_bd_prog(lfs, rbyd->blocks[0], rbyd->eoff,
             cksum_buf, 2+1+5+4,
             NULL);
     if (err) {
@@ -3234,7 +3235,7 @@ static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     }
 
     // write the tag
-    lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff,
+    lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff,
             tag, weight, lfsr_data_size(&data),
             &rbyd->cksum);
     if (d < 0) {
@@ -3243,7 +3244,7 @@ static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     rbyd->eoff += d;
 
     // and the data
-    int err = lfsr_bd_progdata(lfs, rbyd->block, rbyd->eoff, data,
+    int err = lfsr_bd_progdata(lfs, rbyd->blocks[0], rbyd->eoff, data,
             &rbyd->cksum);
     if (err) {
         return err;
@@ -3312,7 +3313,7 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd,
 
     // empty rbyd? write a null tag so our trunk can still point to something
     if (rbyd->eoff == off) {
-        lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff,
+        lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff,
                 shrub ? LFSR_TAG_SHRUB(NULL) : LFSR_TAG_NULL, 0, 0,
                 &rbyd->cksum);
         if (d < 0) {
@@ -3343,7 +3344,7 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd,
                     lfsr_rid_t weight__;
                     lfs_size_t size__;
                     lfs_ssize_t d = lfsr_bd_readtag(lfs,
-                            rbyd->block, off, layer_ - off,
+                            rbyd->blocks[0], off, layer_ - off,
                             &tag__, &weight__, &size__, NULL);
                     if (d < 0) {
                         return d;
@@ -3386,7 +3387,8 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd,
                 }
 
                 // connect with an altle
-                lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff,
+                lfs_ssize_t d = lfsr_bd_progtag(lfs,
+                        rbyd->blocks[0], rbyd->eoff,
                         LFSR_TAG_ALT(LE, B, lfsr_tag_key(tag)),
                         weight,
                         rbyd->eoff - trunk,
@@ -3398,7 +3400,7 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd,
             }
 
             // terminate with a null tag
-            lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff,
+            lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff,
                     shrub ? LFSR_TAG_SHRUB(NULL) : LFSR_TAG_NULL, 0, 0,
                     &rbyd->cksum);
             if (d < 0) {
@@ -3711,7 +3713,7 @@ static lfsr_data_t lfsr_data_frombranch(const lfsr_rbyd_t *branch,
         uint8_t buffer[static LFSR_BRANCH_DSIZE]) {
     lfs_ssize_t d = 0;
 
-    lfs_ssize_t d_ = lfs_toleb128(branch->block, &buffer[d], 5);
+    lfs_ssize_t d_ = lfs_toleb128(branch->blocks[0], &buffer[d], 5);
     LFS_ASSERT(d_ >= 0);
     d += d_;
 
@@ -3733,7 +3735,7 @@ static int lfsr_data_readbranch(lfs_t *lfs, lfsr_data_t *data,
     branch->eoff = 0;
     branch->weight = weight;
 
-    int err = lfsr_data_readleb128(lfs, data, (int32_t*)&branch->block);
+    int err = lfsr_data_readleb128(lfs, data, (int32_t*)&branch->blocks[0]);
     if (err) {
         return err;
     }
@@ -3940,7 +3942,8 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree,
         }
 
         // found our child?
-        if (branch_.block == child->block && branch_.trunk == child->trunk) {
+        if (branch_.blocks[0] == child->blocks[0]
+                && branch_.trunk == child->trunk) {
             // TODO how many of these should be conditional?
             if (rbyd_) {
                 *rbyd_ = branch;
@@ -3998,7 +4001,7 @@ static lfs_ssize_t lfsr_btree_commit_(lfs_t *lfs,
         lfsr_rbyd_t parent = {.trunk=0, .weight=0};
         lfsr_srid_t rid;
         // are we root?
-        if (rbyd.block == btree->block || rbyd.trunk == 0) {
+        if (rbyd.blocks[0] == btree->blocks[0] || rbyd.trunk == 0) {
             // new root? shrub root? yield creation of new roots to
             // higher-level bshrub/btree logic
             if (shrub || rbyd.trunk == 0) {
@@ -4034,7 +4037,7 @@ static lfs_ssize_t lfsr_btree_commit_(lfs_t *lfs,
         // a funny benefit is we cache the root of our btree this way
         if (!lfsr_rbyd_isfetched(&rbyd)) {
             int err = lfsr_rbyd_fetchvalidate(lfs, &rbyd,
-                    rbyd.block, rbyd.trunk, rbyd.weight, rbyd.cksum);
+                    rbyd.blocks[0], rbyd.trunk, rbyd.weight, rbyd.cksum);
             if (err) {
                 return err;
             }
@@ -4728,12 +4731,12 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree,
 
 static inline bool lfsr_bshrub_isbshrub(
         const lfsr_mdir_t *mdir, const lfsr_bshrub_t *bshrub) {
-    return mdir->u.mdir.blocks[0] == bshrub->rbyd.block;
+    return mdir->rbyd.blocks[0] == bshrub->rbyd.blocks[0];
 }
 
 static inline bool lfsr_bshrub_isbtree(
         const lfsr_mdir_t *mdir, const lfsr_bshrub_t *bshrub) {
-    return mdir->u.mdir.blocks[0] != bshrub->rbyd.block;
+    return mdir->rbyd.blocks[0] != bshrub->rbyd.blocks[0];
 }
 
 static inline int lfsr_bshrub_cmp(
@@ -4747,7 +4750,7 @@ static inline int lfsr_bshrub_cmp(
 static int lfsr_bshrub_alloc(lfs_t *lfs,
         const lfsr_mdir_t *mdir, lfsr_bshrub_t *bshrub) {
     (void)lfs;
-    bshrub->rbyd.block = mdir->u.rbyd.block;
+    bshrub->rbyd.blocks[0] = mdir->rbyd.blocks[0];
     bshrub->rbyd.trunk = 0;
     bshrub->rbyd.weight = 0;
     bshrub->progged = 0;
@@ -4759,7 +4762,7 @@ static int lfsr_bshrub_alloc(lfs_t *lfs,
 static int lfsr_bshrub_fetch(lfs_t *lfs,
         const lfsr_mdir_t *mdir, lfsr_bshrub_t *bshrub,
         lfs_size_t trunk, lfsr_rid_t weight) {
-    bshrub->rbyd.block = mdir->u.rbyd.block;
+    bshrub->rbyd.blocks[0] = mdir->rbyd.blocks[0];
     bshrub->rbyd.trunk = trunk;
     bshrub->rbyd.weight = weight;
 
@@ -5006,7 +5009,7 @@ static int lfsr_data_readmptr(lfs_t *lfs, lfsr_data_t *data,
 
 // mdir convenience functions
 static inline const lfsr_mptr_t *lfsr_mdir_mptr(const lfsr_mdir_t *mdir) {
-    return (const lfsr_mptr_t*)mdir->u.mdir.blocks;
+    return (const lfsr_mptr_t*)mdir->rbyd.blocks;
 }
 
 static inline int lfsr_mdir_cmp(const lfsr_mdir_t *a, const lfsr_mdir_t *b) {
@@ -5090,7 +5093,7 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir,
 
     // try to fetch rbyds in the order of most recent to least recent
     for (int i = 0; i < 2; i++) {
-        int err = lfsr_rbyd_fetch(lfs, &mdir->u.rbyd, blocks_[0], 0);
+        int err = lfsr_rbyd_fetch(lfs, &mdir->rbyd, blocks_[0], 0);
         if (err && err != LFS_ERR_CORRUPT) {
             return err;
         }
@@ -5098,7 +5101,7 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir,
         if (err != LFS_ERR_CORRUPT) {
             mdir->mid = mid;
             // keep track of other block for compactions
-            mdir->u.mdir.blocks[1] = blocks_[1];
+            mdir->rbyd.blocks[1] = blocks_[1];
             return 0;
         }
 
@@ -5115,7 +5118,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir,
         lfsr_tag_t *tag_, lfsr_data_t *data_) {
     lfsr_smid_t mid_;
     lfsr_tag_t tag__;
-    int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.rbyd,
+    int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd,
             lfsr_mid_rid(lfs, mid), tag,
             &mid_, &tag__, NULL, data_);
     if (err) {
@@ -5137,7 +5140,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir,
 static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
         lfsr_smid_t mid, lfsr_tag_t tag,
         lfsr_tag_t *tag_, lfsr_data_t *data_) {
-    return lfsr_rbyd_lookup(lfs, &mdir->u.rbyd,
+    return lfsr_rbyd_lookup(lfs, &mdir->rbyd,
             lfsr_mid_rid(lfs, mid), tag,
             tag_, data_);
 }
@@ -5200,7 +5203,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid,
         LFS_ASSERT(mid >= 0);
         LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mweight(lfs));
         mdir_->mid = mid;
-        mdir_->u = lfs->mroot.u;
+        mdir_->rbyd = lfs->mroot.rbyd;
         return 0;
 
     // looking up direct mdir?
@@ -5248,7 +5251,7 @@ static int lfsr_mtree_seek(lfs_t *lfs, lfsr_mdir_t *mdir, lfs_off_t off) {
         lfsr_srid_t rid = lfsr_mdir_rid(lfs, mdir) + off;
         // lookup mdirs until we find our rid, we need to do this because
         // we don't know how many rids are in each mdir until we fetch
-        while (rid >= mdir->u.rbyd.weight) {
+        while (rid >= mdir->rbyd.weight) {
             // end of mtree?
             if (bid+lfsr_mweight(lfs) >= lfsr_mtree_weight(lfs)) {
                 // if we hit the end of the mtree, park the mdir so all future
@@ -5258,7 +5261,7 @@ static int lfsr_mtree_seek(lfs_t *lfs, lfsr_mdir_t *mdir, lfs_off_t off) {
             }
 
             bid += lfsr_mweight(lfs);
-            rid -= mdir->u.rbyd.weight;
+            rid -= mdir->rbyd.weight;
             int err = lfsr_mtree_lookup(lfs, bid, mdir);
             if (err) {
                 return err;
@@ -5284,23 +5287,23 @@ static int lfsr_mdir_alloc(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_smid_t mid) {
 
     // allocate two blocks
     for (int i = 0; i < 2; i++) {
-        int err = lfs_alloc(lfs, &mdir->u.mdir.blocks[i]);
+        int err = lfs_alloc(lfs, &mdir->rbyd.blocks[i]);
         if (err) {
             return err;
         }
     }
 
-    mdir->u.rbyd.weight = 0;
-    mdir->u.rbyd.trunk = 0;
-    mdir->u.rbyd.eoff = 0;
-    mdir->u.rbyd.cksum = 0;
+    mdir->rbyd.weight = 0;
+    mdir->rbyd.trunk = 0;
+    mdir->rbyd.eoff = 0;
+    mdir->rbyd.cksum = 0;
 
     // read the new revision count
     //
     // we use whatever is on-disk to avoid needing to rewrite the
     // redund block
     uint32_t rev;
-    int err = lfsr_bd_read(lfs, mdir->u.mdir.blocks[1], 0, sizeof(uint32_t),
+    int err = lfsr_bd_read(lfs, mdir->rbyd.blocks[1], 0, sizeof(uint32_t),
             &rev, sizeof(uint32_t));
     if (err && err != LFS_ERR_CORRUPT) {
         return err;
@@ -5315,14 +5318,14 @@ static int lfsr_mdir_alloc(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_smid_t mid) {
     }
 
     // erase, preparing for compact
-    err = lfsr_bd_erase(lfs, mdir->u.mdir.blocks[0]);
+    err = lfsr_bd_erase(lfs, mdir->rbyd.blocks[0]);
     if (err) {
         return err;
     }
 
     // increment our revision count and write it to our rbyd
     // TODO rev things
-    err = lfsr_rbyd_appendrev(lfs, &mdir->u.rbyd, rev + 1);
+    err = lfsr_rbyd_appendrev(lfs, &mdir->rbyd, rev + 1);
     if (err) {
         return err;
     }
@@ -5337,7 +5340,7 @@ static int lfsr_mdir_swap(lfs_t *lfs, lfsr_mdir_t *mdir_,
 
     // first thing we need to do is read our current revision count
     uint32_t rev;
-    int err = lfsr_bd_read(lfs, mdir->u.mdir.blocks[0], 0, sizeof(uint32_t),
+    int err = lfsr_bd_read(lfs, mdir->rbyd.blocks[0], 0, sizeof(uint32_t),
             &rev, sizeof(uint32_t));
     if (err && err != LFS_ERR_CORRUPT) {
         return err;
@@ -5355,22 +5358,22 @@ static int lfsr_mdir_swap(lfs_t *lfs, lfsr_mdir_t *mdir_,
     }
 
     // swap our blocks
-    mdir_->u.mdir.blocks[0] = mdir->u.mdir.blocks[1];
-    mdir_->u.mdir.blocks[1] = mdir->u.mdir.blocks[0];
-    mdir_->u.rbyd.weight = 0;
-    mdir_->u.rbyd.trunk = 0;
-    mdir_->u.rbyd.eoff = 0;
-    mdir_->u.rbyd.cksum = 0;
+    mdir_->rbyd.blocks[0] = mdir->rbyd.blocks[1];
+    mdir_->rbyd.blocks[1] = mdir->rbyd.blocks[0];
+    mdir_->rbyd.weight = 0;
+    mdir_->rbyd.trunk = 0;
+    mdir_->rbyd.eoff = 0;
+    mdir_->rbyd.cksum = 0;
 
     // erase, preparing for compact
-    err = lfsr_bd_erase(lfs, mdir_->u.mdir.blocks[0]);
+    err = lfsr_bd_erase(lfs, mdir_->rbyd.blocks[0]);
     if (err) {
         return err;
     }
 
     // increment our revision count and write it to our rbyd
     // TODO rev things
-    err = lfsr_rbyd_appendrev(lfs, &mdir_->u.rbyd, rev + 1);
+    err = lfsr_rbyd_appendrev(lfs, &mdir_->rbyd, rev + 1);
     if (err) {
         return err;
     }
@@ -5396,7 +5399,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
     // try to append a commit
     lfsr_mdir_t mdir_ = *mdir;
     // mark as erased in case of failure
-    mdir->u.rbyd.eoff = -1;
+    mdir->rbyd.eoff = -1;
     for (lfs_size_t i = 0; i < attr_count; i++) {
         // calculate adjusted rid
         lfsr_srid_t rid = lfsr_mid_rid(lfs, attrs[i].rid);
@@ -5434,7 +5437,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                     }
 
                     // append the attr
-                    err = lfsr_rbyd_appendattr(lfs, &mdir_.u.rbyd,
+                    err = lfsr_rbyd_appendattr(lfs, &mdir_.rbyd,
                             rid - lfs_smax32(start_rid, 0),
                             tag, 0, data);
                     if (err) {
@@ -5455,12 +5458,12 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                 //
                 // it is important that these rbyds share eoff/cksum/etc
                 //
-                mdir_.u.rbyd.trunk = bshrubcommit->bshrub->rbyd_.trunk;
-                mdir_.u.rbyd.weight = bshrubcommit->bshrub->rbyd_.weight;
+                mdir_.rbyd.trunk = bshrubcommit->bshrub->rbyd_.trunk;
+                mdir_.rbyd.weight = bshrubcommit->bshrub->rbyd_.weight;
 
                 // append any shrub attributes
                 for (lfs_size_t j = 0; j < bshrubcommit->attr_count; j++) {
-                    int err = lfsr_rbyd_appendattr(lfs, &mdir_.u.rbyd,
+                    int err = lfsr_rbyd_appendattr(lfs, &mdir_.rbyd,
                             bshrubcommit->attrs[j].rid,
                             LFSR_TAG_SHRUB | bshrubcommit->attrs[j].tag,
                             bshrubcommit->attrs[j].delta,
@@ -5471,10 +5474,10 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                 }
 
                 // revert mdir to main trunk/weight
-                bshrubcommit->bshrub->rbyd_.trunk = mdir_.u.rbyd.trunk;
-                bshrubcommit->bshrub->rbyd_.weight = mdir_.u.rbyd.weight;
-                mdir_.u.rbyd.trunk = mdir->u.rbyd.trunk;
-                mdir_.u.rbyd.weight = mdir->u.rbyd.weight;
+                bshrubcommit->bshrub->rbyd_.trunk = mdir_.rbyd.trunk;
+                bshrubcommit->bshrub->rbyd_.weight = mdir_.rbyd.weight;
+                mdir_.rbyd.trunk = mdir->rbyd.trunk;
+                mdir_.rbyd.weight = mdir->rbyd.weight;
 
             // lazily encode inlined trunks in case they change underneath
             // us due to mdir compactions
@@ -5486,7 +5489,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                         = (lfsr_bshrub_t*)attrs[i].data.u.buf.buffer;
 
                 uint8_t trunk_buf[LFSR_TRUNK_DSIZE];
-                int err = lfsr_rbyd_appendattr(lfs, &mdir_.u.rbyd,
+                int err = lfsr_rbyd_appendattr(lfs, &mdir_.rbyd,
                         rid - lfs_smax32(start_rid, 0),
                         lfsr_tag_mode(attrs[i].tag) | LFSR_TAG_TRUNK,
                         attrs[i].delta,
@@ -5503,7 +5506,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
             } else {
                 LFS_ASSERT(!lfsr_tag_isinternal(attrs[i].tag));
 
-                int err = lfsr_rbyd_appendattr(lfs, &mdir_.u.rbyd,
+                int err = lfsr_rbyd_appendattr(lfs, &mdir_.rbyd,
                         rid - lfs_smax32(start_rid, 0),
                         attrs[i].tag, attrs[i].delta, attrs[i].data);
                 if (err) {
@@ -5527,25 +5530,25 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
     // If we finish the commit it becomes immediately visibile, but we really
     // need to remove this mdir_ from the mtree. Leave the actual remove up to
     // upper layers.
-    if (mdir_.u.rbyd.weight == 0
+    if (mdir_.rbyd.weight == 0
             // unless we are an mroot
             && !(mdir_.mid == -1 || lfsr_mdir_cmp(&mdir_, &lfs->mroot) == 0)) {
         // mark weight as zero, but note! we can not longer read from this mdir
         // as our pcache may get clobbered
-        mdir->u.rbyd.weight = 0;
+        mdir->rbyd.weight = 0;
         return LFS_ERR_NOENT;
     }
 
     // append any gstate?
     if (start_rid == -1) {
-        int err = lfsr_rbyd_appendgdelta(lfs, &mdir_.u.rbyd);
+        int err = lfsr_rbyd_appendgdelta(lfs, &mdir_.rbyd);
         if (err) {
             return err;
         }
     }
 
     // finalize commit
-    int err = lfsr_rbyd_appendcksum(lfs, &mdir_.u.rbyd);
+    int err = lfsr_rbyd_appendcksum(lfs, &mdir_.rbyd);
     if (err) {
         return err;
     }
@@ -5555,7 +5558,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
         lfsr_fs_flushgdelta(lfs);
     }
 
-    mdir->u = mdir_.u;
+    mdir->rbyd = mdir_.rbyd;
     return 0;
 }
 
@@ -5579,7 +5582,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
     while (true) {
         lfsr_rid_t weight;
         lfsr_data_t data;
-        int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.rbyd,
+        int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd,
                 rid, tag+1,
                 &rid, &tag, &weight, &data);
         if (err) {
@@ -5599,7 +5602,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
         // we need to update any opened inlined files
         if (tag == LFSR_TAG_DATA) {
             // write the tag
-            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->u.rbyd,
+            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
                     tag, weight, data);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -5621,8 +5624,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
                     // this is a bit tricky since we don't know the tag size,
                     // but we have just enough info
                     file->u.bsprout.data = LFSR_DATA_DISK(
-                            mdir_->u.rbyd.block,
-                            mdir_->u.rbyd.eoff - lfsr_data_size(&data),
+                            mdir_->rbyd.blocks[0],
+                            mdir_->rbyd.eoff - lfsr_data_size(&data),
                             lfsr_data_size(&data));
                 }
             }
@@ -5630,7 +5633,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
         // found an inlined shrub? we need to compact the shrub as well to
         // bring it along with us
         } else if (tag == LFSR_TAG_TRUNK) {
-            lfsr_rbyd_t shrub = mdir->u.rbyd;
+            lfsr_rbyd_t shrub = mdir->rbyd;
             err = lfsr_data_readtrunk(lfs, &data,
                     &shrub.trunk, (lfsr_rid_t*)&shrub.weight);
             if (err) {
@@ -5638,17 +5641,17 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
             }
 
             // keep track of the start of our new tree
-            lfs_size_t off = mdir_->u.rbyd.eoff;
+            lfs_size_t off = mdir_->rbyd.eoff;
 
             // compact our inlined tree
-            err = lfsr_rbyd_appendcompactrbyd(lfs, &mdir_->u.rbyd, true,
+            err = lfsr_rbyd_appendcompactrbyd(lfs, &mdir_->rbyd, true,
                     -1, -1, &shrub);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
             }
 
-            err = lfsr_rbyd_compact(lfs, &mdir_->u.rbyd, true, off);
+            err = lfsr_rbyd_compact(lfs, &mdir_->rbyd, true, off);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
@@ -5656,9 +5659,9 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
 
             // write the new shrub tag
             uint8_t trunk_buf[LFSR_TRUNK_DSIZE];
-            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->u.rbyd,
+            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
                     LFSR_TAG_TRUNK, weight, lfsr_data_fromtrunk(
-                        mdir_->u.rbyd.trunk, mdir_->u.rbyd.weight,
+                        mdir_->rbyd.trunk, mdir_->rbyd.weight,
                         trunk_buf));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -5674,13 +5677,13 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
                 lfsr_file_t *file = (lfsr_file_t*)opened;
                 if (lfsr_file_isbshrub(file)
                         && lfsr_rbyd_cmp(&file->u.bshrub.rbyd, &shrub) == 0) {
-                    file->u.bshrub.rbyd_ = mdir_->u.rbyd;
+                    file->u.bshrub.rbyd_ = mdir_->rbyd;
                 }
             }
 
         } else {
             // write the tag
-            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->u.rbyd,
+            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
                     tag, weight, data);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -5689,7 +5692,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
         }
     }
 
-    int err = lfsr_rbyd_compact(lfs, &mdir_->u.rbyd, false, sizeof(uint32_t));
+    int err = lfsr_rbyd_compact(lfs, &mdir_->rbyd, false, sizeof(uint32_t));
     if (err) {
         LFS_ASSERT(err != LFS_ERR_RANGE);
         return err;
@@ -5714,7 +5717,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
             // inlined sprout?
             if (lfsr_file_isbsprout(file)) {
                 // write the data as a shrub tag
-                err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->u.rbyd,
+                err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
                         LFSR_TAG_SHRUB(DATA), 0, file->u.bsprout.data);
                 if (err) {
                     LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -5724,20 +5727,20 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
                 // this is a bit tricky since we don't know the tag size,
                 // but we have just enough info
                 file->u.bsprout.data_ = LFSR_DATA_DISK(
-                        mdir_->u.rbyd.block,
-                        mdir_->u.rbyd.eoff
+                        mdir_->rbyd.blocks[0],
+                        mdir_->rbyd.eoff
                             - lfsr_data_size(&file->u.bsprout.data),
                         lfsr_data_size(&file->u.bsprout.data));
 
             // inlined shrub?
             } else if (lfsr_file_isbshrub(file)) {
                 // save our current off/trunk/weight
-                lfs_size_t off = mdir_->u.rbyd.eoff;
-                lfs_size_t trunk = mdir_->u.rbyd.trunk;
-                lfsr_srid_t weight = mdir_->u.rbyd.weight;
+                lfs_size_t off = mdir_->rbyd.eoff;
+                lfs_size_t trunk = mdir_->rbyd.trunk;
+                lfsr_srid_t weight = mdir_->rbyd.weight;
 
                 // compact our shrub
-                err = lfsr_rbyd_appendcompactrbyd(lfs, &mdir_->u.rbyd, true,
+                err = lfsr_rbyd_appendcompactrbyd(lfs, &mdir_->rbyd, true,
                         -1, -1,
                         &file->u.bshrub.rbyd);
                 if (err) {
@@ -5745,16 +5748,16 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
                     return err;
                 }
 
-                err = lfsr_rbyd_compact(lfs, &mdir_->u.rbyd, true, off);
+                err = lfsr_rbyd_compact(lfs, &mdir_->rbyd, true, off);
                 if (err) {
                     LFS_ASSERT(err != LFS_ERR_RANGE);
                     return err;
                 }
 
                 // stage our new trunk and revert to mdir trunk/weight
-                file->u.bshrub.rbyd_ = mdir_->u.rbyd;
-                mdir_->u.rbyd.trunk = trunk;
-                mdir_->u.rbyd.weight = weight;
+                file->u.bshrub.rbyd_ = mdir_->rbyd;
+                mdir_->rbyd.trunk = trunk;
+                mdir_->rbyd.weight = weight;
             }
         }
     }
@@ -5771,7 +5774,7 @@ static lfs_ssize_t lfsr_mdir_estimate_(lfs_t *lfs, const lfsr_mdir_t *mdir,
     while (true) {
         lfsr_srid_t rid__;
         lfsr_data_t data;
-        int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.rbyd,
+        int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd,
                 rid, tag+1,
                 &rid__, &tag, NULL, &data);
         if (err) {
@@ -5791,7 +5794,7 @@ static lfs_ssize_t lfsr_mdir_estimate_(lfs_t *lfs, const lfsr_mdir_t *mdir,
         // need a second function...
         //
         if (tag == LFSR_TAG_TRUNK) {
-            lfsr_rbyd_t rbyd = mdir->u.rbyd;
+            lfsr_rbyd_t rbyd = mdir->rbyd;
             err = lfsr_data_readtrunk(lfs, &data,
                     &rbyd.trunk, (lfsr_rid_t*)&rbyd.weight);
             if (err) {
@@ -5864,7 +5867,7 @@ static lfs_ssize_t lfsr_mdir_estimate(lfs_t *lfs, const lfsr_mdir_t *mdir,
     // during a split so they shouldn't affect the split_rid
     //
     lfsr_srid_t lower_rid = lfs_smax32(start_rid, 0);
-    lfsr_srid_t upper_rid = lfs_min32(mdir->u.rbyd.weight, end_rid)-1;
+    lfsr_srid_t upper_rid = lfs_min32(mdir->rbyd.weight, end_rid)-1;
     lfs_size_t lower_dsize = 0;
     lfs_size_t upper_dsize = 0;
 
@@ -5894,7 +5897,7 @@ static lfs_ssize_t lfsr_mdir_estimate(lfs_t *lfs, const lfsr_mdir_t *mdir,
     // can't handle -1 rids
     lfs_ssize_t dsize = 0;
     if (start_rid == -1) {
-        dsize = lfsr_rbyd_estimate_(lfs, &mdir->u.rbyd, -1, NULL, NULL);
+        dsize = lfsr_rbyd_estimate_(lfs, &mdir->rbyd, -1, NULL, NULL);
         if (dsize < 0) {
             return dsize;
         }
@@ -6021,14 +6024,14 @@ static int lfsr_mroot_commit(lfs_t *lfs,
     lfsr_mdir_t mroot_ = lfs->mroot;
 
     // mark any copies of our mroot as unerased
-    lfs->mroot.u.rbyd.eoff = -1;
+    lfs->mroot.rbyd.eoff = -1;
 
     for (int type = LFS_TYPE_REG; type < LFS_TYPE_REG+3; type++) {
         for (lfsr_openedmdir_t *opened = lfs->opened[type-LFS_TYPE_REG];
                 opened;
                 opened = opened->next) {
             if (lfsr_mdir_cmp(&opened->mdir, &lfs->mroot) == 0) {
-                opened->mdir.u.rbyd.eoff = -1;
+                opened->mdir.rbyd.eoff = -1;
             }
         }
     }
@@ -6058,8 +6061,8 @@ static int lfsr_mroot_commit(lfs_t *lfs,
 
         LFS_DEBUG("Relocating mroot 0x{%"PRIx32",%"PRIx32"} "
                 "-> 0x{%"PRIx32",%"PRIx32"}",
-                mrootchild.u.mdir.blocks[0], mrootchild.u.mdir.blocks[1],
-                mrootchild_.u.mdir.blocks[0], mrootchild_.u.mdir.blocks[1]);
+                mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1],
+                mrootchild_.rbyd.blocks[0], mrootchild_.rbyd.blocks[1]);
 
         mrootchild = mrootparent_;
 
@@ -6085,9 +6088,9 @@ static int lfsr_mroot_commit(lfs_t *lfs,
         LFS_DEBUG("Extending mroot 0x{%"PRIx32",%"PRIx32"}"
                 " -> 0x{%"PRIx32",%"PRIx32"}"
                 ", 0x{%"PRIx32",%"PRIx32"}",
-                mrootchild.u.mdir.blocks[0], mrootchild.u.mdir.blocks[1],
-                mrootchild.u.mdir.blocks[0], mrootchild.u.mdir.blocks[1],
-                mrootchild_.u.mdir.blocks[0], mrootchild_.u.mdir.blocks[1]);
+                mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1],
+                mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1],
+                mrootchild_.rbyd.blocks[0], mrootchild_.rbyd.blocks[1]);
 
         // compact into the new mroot anchor
         lfsr_mdir_t mrootanchor_;
@@ -6102,7 +6105,7 @@ static int lfsr_mroot_commit(lfs_t *lfs,
             lfsr_srid_t rid;
             lfsr_rid_t weight;
             lfsr_data_t data;
-            err = lfsr_rbyd_lookupnext(lfs, &mrootchild.u.rbyd,
+            err = lfsr_rbyd_lookupnext(lfs, &mrootchild.rbyd,
                     -1, tag+1,
                     &rid, &tag, &weight, &data);
             if (err) {
@@ -6116,7 +6119,7 @@ static int lfsr_mroot_commit(lfs_t *lfs,
             }
 
             // write the tag
-            err = lfsr_rbyd_appendcompactattr(lfs, &mrootanchor_.u.rbyd,
+            err = lfsr_rbyd_appendcompactattr(lfs, &mrootanchor_.rbyd,
                     tag, weight, data);
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -6124,7 +6127,7 @@ static int lfsr_mroot_commit(lfs_t *lfs,
             }
         }
 
-        err = lfsr_rbyd_compact(lfs, &mrootanchor_.u.rbyd, false,
+        err = lfsr_rbyd_compact(lfs, &mrootanchor_.rbyd, false,
                 sizeof(uint32_t));
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -6163,7 +6166,7 @@ static int lfsr_mroot_commit(lfs_t *lfs,
                 }
 
                 // update any opened mdirs in our mroot
-                opened->mdir.u = mroot_.u;
+                opened->mdir.rbyd = mroot_.rbyd;
             }
         }
     }
@@ -6235,8 +6238,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         const lfsr_attr_t *attrs, lfs_size_t attr_count) {
     LFS_ASSERT(mdir->mid == -1
             || lfsr_mtree_isnull(lfs)
-            || mdir->u.rbyd.weight > 0);
-    LFS_ASSERT(lfsr_mdir_rid(lfs, mdir) <= mdir->u.rbyd.weight);
+            || mdir->rbyd.weight > 0);
+    LFS_ASSERT(lfsr_mdir_rid(lfs, mdir) <= mdir->rbyd.weight);
 
     // parse out any pending gstate, these will get automatically xored
     // with on-disk gdeltas in lower-level functions
@@ -6271,7 +6274,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
             // would force the mroot to always compact
             //
             if (lfsr_mdir_cmp(&opened->mdir, mdir) == 0) {
-                opened->mdir.u.rbyd.eoff = -1;
+                opened->mdir.rbyd.eoff = -1;
             }
 
             // stage all bsprouts/bshrubs
@@ -6299,12 +6302,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         }
 
         // keep mdir_ in sync with mroot
-        mdir_.u = lfs->mroot.u;
+        mdir_.rbyd = lfs->mroot.rbyd;
 
     // otherwise commit normally
     } else {
         // mark our mdir as unerased in case we fail
-        mdir->u.rbyd.eoff = -1;
+        mdir->rbyd.eoff = -1;
 
         err = lfsr_mdir_commit_(lfs, &mdir_, -1, -1, &split_rid,
                 attrs, attr_count);
@@ -6380,40 +6383,40 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                 "-> 0x{%"PRIx32",%"PRIx32"}, "
                 "0x{%"PRIx32",%"PRIx32"}",
                 mdir->mid >> lfs->mbits,
-                mdir->u.mdir.blocks[0], mdir->u.mdir.blocks[1],
-                mdir_.u.mdir.blocks[0], mdir_.u.mdir.blocks[1],
-                msibling_.u.mdir.blocks[0], msibling_.u.mdir.blocks[1]);
+                mdir->rbyd.blocks[0], mdir->rbyd.blocks[1],
+                mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1],
+                msibling_.rbyd.blocks[0], msibling_.rbyd.blocks[1]);
 
         // because of defered commits, both children can still be reduced
         // to zero, need to catch this here
 
         // both siblings reduced to zero
-        if (mdir_.u.rbyd.weight == 0 && msibling_.u.rbyd.weight == 0) {
+        if (mdir_.rbyd.weight == 0 && msibling_.rbyd.weight == 0) {
             LFS_DEBUG("Dropping mdir %"PRId32" "
                     "0x{%"PRIx32",%"PRIx32"}",
                     mdir_.mid >> lfs->mbits,
-                    mdir_.u.mdir.blocks[0], mdir_.u.mdir.blocks[1]);
+                    mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1]);
             LFS_DEBUG("Dropping mdir %"PRId32" "
                     "0x{%"PRIx32",%"PRIx32"}",
                     msibling_.mid >> lfs->mbits,
-                    msibling_.u.mdir.blocks[0], msibling_.u.mdir.blocks[1]);
+                    msibling_.rbyd.blocks[0], msibling_.rbyd.blocks[1]);
             goto drop;
 
         // one sibling reduced to zero
-        } else if (msibling_.u.rbyd.weight == 0) {
+        } else if (msibling_.rbyd.weight == 0) {
             LFS_DEBUG("Dropping mdir %"PRId32" "
                     "0x{%"PRIx32",%"PRIx32"}",
                     msibling_.mid >> lfs->mbits,
-                    msibling_.u.mdir.blocks[0], msibling_.u.mdir.blocks[1]);
+                    msibling_.rbyd.blocks[0], msibling_.rbyd.blocks[1]);
             goto relocate;
 
         // other sibling reduced to zero
-        } else if (mdir_.u.rbyd.weight == 0) {
+        } else if (mdir_.rbyd.weight == 0) {
             LFS_DEBUG("Dropping mdir %"PRId32" "
                     "0x{%"PRIx32",%"PRIx32"}",
                     mdir_.mid >> lfs->mbits,
-                    mdir_.u.mdir.blocks[0], mdir_.u.mdir.blocks[1]);
-            mdir_.u = msibling_.u;
+                    mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1]);
+            mdir_.rbyd = msibling_.rbyd;
             goto relocate;
         }
 
@@ -6443,9 +6446,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                     if (lfsr_mid_bid(lfs, grm->rms[j])
                             == lfsr_mid_bid(lfs, lfs_smax32(mdir->mid, 0))) {
                         if (lfsr_mid_rid(lfs, grm->rms[j])
-                                >= mdir_.u.rbyd.weight) {
+                                >= mdir_.rbyd.weight) {
                             grm->rms[j] += lfsr_mweight(lfs)
-                                    - mdir_.u.rbyd.weight;
+                                    - mdir_.rbyd.weight;
                         }
                     } else if (grm->rms[j] > mdir->mid) {
                         grm->rms[j] += mdelta;
@@ -6466,7 +6469,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         // note we need to do this after playing out pending attrs in
         // case they introduce a new name!
         lfsr_data_t split_data;
-        err = lfsr_rbyd_lookup(lfs, &msibling_.u.rbyd, 0, LFSR_TAG_WIDE(NAME),
+        err = lfsr_rbyd_lookup(lfs, &msibling_.rbyd, 0, LFSR_TAG_WIDE(NAME),
                 NULL, &split_data);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -6512,7 +6515,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         LFS_DEBUG("Dropping mdir %"PRId32" "
                 "0x{%"PRIx32",%"PRIx32"}",
                 mdir->mid >> lfs->mbits,
-                mdir->u.mdir.blocks[0], mdir->u.mdir.blocks[1]);
+                mdir->rbyd.blocks[0], mdir->rbyd.blocks[1]);
 
         // consume gstate so we don't lose any info
         err = lfsr_fs_consumegdelta(lfs, mdir);
@@ -6584,8 +6587,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         LFS_DEBUG("Relocating mdir %"PRId32" "
                 "0x{%"PRIx32",%"PRIx32"} -> 0x{%"PRIx32",%"PRIx32"}",
                 mdir->mid >> lfs->mbits,
-                mdir->u.mdir.blocks[0], mdir->u.mdir.blocks[1],
-                mdir_.u.mdir.blocks[0], mdir_.u.mdir.blocks[1]);
+                mdir->rbyd.blocks[0], mdir->rbyd.blocks[1],
+                mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1]);
 
     relocate:;
         // new mtree?
@@ -6685,12 +6688,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
             if (lfsr_mdir_cmp(&opened->mdir, mdir) == 0) {
                 if (mdelta > 0
                         && lfsr_mdir_rid(lfs, &opened->mdir)
-                            >= mdir_.u.rbyd.weight) {
+                            >= mdir_.rbyd.weight) {
                     opened->mdir.mid += lfsr_mweight(lfs)
-                            - mdir_.u.rbyd.weight;
-                    opened->mdir.u = msibling_.u;
+                            - mdir_.rbyd.weight;
+                    opened->mdir.rbyd = msibling_.rbyd;
                 } else {
-                    opened->mdir.u = mdir_.u;
+                    opened->mdir.rbyd = mdir_.rbyd;
                 }
             } else if (opened->mdir.mid > mdir->mid) {
                 opened->mdir.mid += mdelta;
@@ -6727,9 +6730,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                         == lfsr_mid_bid(lfs, lfs_smax32(mdir->mid, 0))) {
                     if (mdelta > 0
                             && lfsr_mid_rid(lfs, dir->bookmark)
-                                >= mdir_.u.rbyd.weight) {
+                                >= mdir_.rbyd.weight) {
                         dir->bookmark += lfsr_mweight(lfs)
-                                - mdir_.u.rbyd.weight;
+                                - mdir_.rbyd.weight;
                     }
                 } else if (dir->bookmark > mdir->mid) {
                     dir->bookmark += mdelta;
@@ -6741,13 +6744,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
 
     // update mdir to follow requested rid
     if (mdir->mid == -1) {
-        mdir->u = lfs->mroot.u;
+        mdir->rbyd = lfs->mroot.rbyd;
     } else if (mdelta > 0
-            && lfsr_mdir_rid(lfs, mdir) >= mdir_.u.rbyd.weight) {
-        mdir->mid += lfsr_mweight(lfs) - mdir_.u.rbyd.weight;
-        mdir->u = msibling_.u;
+            && lfsr_mdir_rid(lfs, mdir) >= mdir_.rbyd.weight) {
+        mdir->mid += lfsr_mweight(lfs) - mdir_.rbyd.weight;
+        mdir->rbyd = msibling_.rbyd;
     } else {
-        mdir->u = mdir_.u;
+        mdir->rbyd = mdir_.rbyd;
     }
 
     return 0;
@@ -6761,7 +6764,7 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
         lfsr_did_t did, const char *name, lfs_size_t name_size,
         lfsr_srid_t *rid_, lfsr_tag_t *tag_, lfsr_data_t *data_) {
     // empty mdir? make sure rid_ = 0 at least
-    if (mdir->u.rbyd.weight == 0) {
+    if (mdir->rbyd.weight == 0) {
         if (rid_) {
             *rid_ = 0;
         }
@@ -6769,7 +6772,7 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
     }
 
     lfsr_srid_t rid;
-    lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->u.rbyd,
+    lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->rbyd,
             did, name, name_size,
             &rid, tag_, NULL, data_);
     if (cmp < 0) {
@@ -7187,7 +7190,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal,
                 // match
                 if (lfsr_traversal_isvalidate(traversal)) {
                     err = lfsr_rbyd_fetchvalidate(lfs, &tinfo->u.rbyd,
-                            tinfo->u.rbyd.block, tinfo->u.rbyd.trunk,
+                            tinfo->u.rbyd.blocks[0], tinfo->u.rbyd.trunk,
                             tinfo->u.rbyd.weight,
                             tinfo->u.rbyd.cksum);
                     if (err) {
@@ -7237,7 +7240,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal,
             // uninitialized in mountinited and 2. stack really matters since
             // we're at the bottom of lfs_alloc)
             if (binfo.tag == LFSR_TAG_BRANCH
-                    && binfo.u.rbyd.block == lfs->mtree.u.btree.block) {
+                    && binfo.u.rbyd.blocks[0] == lfs->mtree.u.btree.blocks[0]) {
                 continue;
             }
 
@@ -7248,7 +7251,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal,
                 // match
                 if (lfsr_traversal_isvalidate(traversal)) {
                     err = lfsr_rbyd_fetchvalidate(lfs, &binfo.u.rbyd,
-                            binfo.u.rbyd.block, binfo.u.rbyd.trunk,
+                            binfo.u.rbyd.blocks[0], binfo.u.rbyd.trunk,
                             binfo.u.rbyd.weight,
                             binfo.u.rbyd.cksum);
                     if (err) {
@@ -7293,7 +7296,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal,
             // return to mtree traversal
             if (!lfsr_traversal_isall(traversal)
                     || lfsr_mdir_rid(lfs, &traversal->mdir)
-                        >= traversal->mdir.u.rbyd.weight) {
+                        >= traversal->mdir.rbyd.weight) {
                 traversal->state = LFSR_TRAVERSAL_MTREE;
                 continue;
             }
@@ -7323,7 +7326,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal,
 
             // found a bshrub (inlined btree)?
             } else if (err != LFS_ERR_NOENT && tag == LFSR_TAG_TRUNK) {
-                traversal->bshrub.rbyd = traversal->mdir.u.rbyd;
+                traversal->bshrub.rbyd = traversal->mdir.rbyd;
                 err = lfsr_data_readtrunk(lfs, &data,
                         &traversal->bshrub.rbyd.trunk,
                         (lfsr_rid_t*)&traversal->bshrub.rbyd.weight);
@@ -7425,7 +7428,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal,
                 // match
                 if (lfsr_traversal_isvalidate(traversal)) {
                     err = lfsr_rbyd_fetchvalidate(lfs, &binfo.u.rbyd,
-                            binfo.u.rbyd.block, binfo.u.rbyd.trunk,
+                            binfo.u.rbyd.blocks[0], binfo.u.rbyd.trunk,
                             binfo.u.rbyd.weight,
                             binfo.u.rbyd.cksum);
                     if (err) {
@@ -8067,9 +8070,9 @@ static int lfsr_formatinited(lfs_t *lfs) {
     for (int i = 0; i < 2; i++) {
         // write superblock to both rbyds in the root mroot to hopefully
         // avoid mounting an older filesystem on disk
-        lfsr_rbyd_t rbyd = {.block=i, .eoff=0, .trunk=0};
+        lfsr_rbyd_t rbyd = {.blocks[0]=i, .eoff=0, .trunk=0};
 
-        int err = lfsr_bd_erase(lfs, rbyd.block);
+        int err = lfsr_bd_erase(lfs, rbyd.blocks[0]);
         if (err) {
             return err;
         }
@@ -8136,9 +8139,9 @@ int lfsr_mount(lfs_t *lfs, const struct lfs_config *cfg) {
             "bd %"PRId32"x%"PRId32,
             LFS_DISK_VERSION_MAJOR,
             LFS_DISK_VERSION_MINOR,
-            lfs->mroot.u.mdir.blocks[0],
-            lfs->mroot.u.mdir.blocks[1],
-            lfs->mroot.u.rbyd.trunk,
+            lfs->mroot.rbyd.blocks[0],
+            lfs->mroot.rbyd.blocks[1],
+            lfs->mroot.rbyd.trunk,
             lfsr_mtree_weight(lfs) / lfsr_mweight(lfs),
             lfsr_mweight(lfs),
             lfs->cfg->block_size,
@@ -8267,11 +8270,11 @@ static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) {
 
             // mark any blocks we see at in-use, including any btree/mdir blocks
             if (tinfo.tag == LFSR_TAG_MDIR) {
-                lfs_alloc_setinuse(lfs, tinfo.u.mdir.u.mdir.blocks[1]);
-                lfs_alloc_setinuse(lfs, tinfo.u.mdir.u.mdir.blocks[0]);
+                lfs_alloc_setinuse(lfs, tinfo.u.mdir.rbyd.blocks[1]);
+                lfs_alloc_setinuse(lfs, tinfo.u.mdir.rbyd.blocks[0]);
 
             } else if (tinfo.tag == LFSR_TAG_BRANCH) {
-                lfs_alloc_setinuse(lfs, tinfo.u.rbyd.block);
+                lfs_alloc_setinuse(lfs, tinfo.u.rbyd.blocks[0]);
 
             } else if (tinfo.tag == LFSR_TAG_BLOCK) {
                 lfs_alloc_setinuse(lfs, tinfo.u.bptr.block);
@@ -8348,7 +8351,7 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) {
         }
 
         // remove the rid while also updating our grm
-        LFS_ASSERT(lfsr_mid_rid(lfs, lfs->grm.rms[0]) < mdir.u.rbyd.weight);
+        LFS_ASSERT(lfsr_mid_rid(lfs, lfs->grm.rms[0]) < mdir.rbyd.weight);
         err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
                 LFSR_ATTR(mdir.mid, RM, -1, NULL()),
                 LFSR_ATTR(-1, GRM, 0, GRM(&grm))));
@@ -9008,14 +9011,14 @@ static inline bool lfsr_file_isbsprout(const lfsr_file_t *file) {
     return (lfs_size_t)file->u.bsprout.data.u.disk.size
                 > (LFSR_FILE_ISDIRECT | 0)
             && file->u.bsprout.data.u.disk.block
-                == file->mdir.u.mdir.blocks[0];
+                == file->mdir.rbyd.blocks[0];
 }
 
 static inline bool lfsr_file_isbptr(const lfsr_file_t *file) {
     return (lfs_size_t)file->u.bsprout.data.u.disk.size
                 > (LFSR_FILE_ISDIRECT | 0)
             && file->u.bsprout.data.u.disk.block
-                != file->mdir.u.mdir.blocks[0];
+                != file->mdir.rbyd.blocks[0];
 }
 
 static inline bool lfsr_file_isbshrub(const lfsr_file_t *file) {
diff --git a/lfs.h b/lfs.h
index fa228d33..2a052e3b 100644
--- a/lfs.h
+++ b/lfs.h
@@ -363,14 +363,13 @@ typedef struct lfs_cache {
 typedef struct lfsr_rbyd {
     // note this lines up with weight in lfsr_btree_t
     lfsr_srid_t weight;
+    lfs_block_t blocks[2];
     // eoff=0, trunk=0  => not yet committed
     // eoff=0, trunk>0  => not yet fetched
     // eoff>=block_size => rbyd not erased/needs compaction
     lfs_size_t trunk;
     lfs_size_t eoff;
     uint32_t cksum;
-    // note this lines up with arrays of redundant blocks in lfsr_mdir_t
-    lfs_block_t block;
 } lfsr_rbyd_t;
 
 typedef struct lfsr_bptr {
@@ -389,18 +388,7 @@ typedef struct lfsr_mptr {
 
 typedef struct lfsr_mdir {
     lfsr_smid_t mid;
-    union {
-        // here we make sure to line up our block array so it overlaps with
-        // the block stored as the first entry in the rbyd
-        struct {
-            lfsr_srid_t weight;
-            lfs_off_t trunk;
-            lfs_off_t eoff;
-            uint32_t cksum;
-            lfs_block_t blocks[2];
-        } mdir;
-        lfsr_rbyd_t rbyd;
-    } u;
+    lfsr_rbyd_t rbyd;
 } lfsr_mdir_t;
 
 typedef struct lfsr_openedmdir {
diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml
index 1b848cba..31f77c4e 100644
--- a/tests/test_alloc.toml
+++ b/tests/test_alloc.toml
@@ -176,22 +176,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else {
             // this shouldn't happen
@@ -332,22 +333,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BLOCK) {
             printf("traversal: 0x%x block 0x%x\n",
@@ -478,22 +480,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BLOCK) {
             printf("traversal: 0x%x block 0x%x\n",
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index a15e1184..4d707359 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -120,7 +120,7 @@ code = '''
     lfsr_btree_alloc(&lfs, &btree) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 0);
 
@@ -154,7 +154,7 @@ code = '''
             LFSR_DATA_BUF("a", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -196,7 +196,7 @@ code = '''
             LFSR_DATA_BUF("b", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 2);
 
@@ -243,7 +243,7 @@ code = '''
             LFSR_DATA_BUF("a", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 2);
 
@@ -293,7 +293,7 @@ code = '''
             LFSR_DATA_BUF("c", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 3);
 
@@ -348,7 +348,7 @@ code = '''
             LFSR_DATA_BUF("a", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 3);
 
@@ -412,7 +412,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == n);
 
@@ -465,7 +465,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == n);
 
@@ -549,7 +549,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == sim_size);
 
@@ -605,7 +605,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == n*W);
 
@@ -727,7 +727,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
 
     lfs_size_t total_weight = 0;
@@ -810,7 +810,7 @@ code = '''
             LFSR_DATA_BUF("A", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -856,7 +856,7 @@ code = '''
             LFSR_DATA_BUF("B", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 2);
 
@@ -912,7 +912,7 @@ code = '''
             LFSR_DATA_BUF("C", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 3);
 
@@ -969,7 +969,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -983,7 +983,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -991,7 +991,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == N);
 
@@ -1042,7 +1042,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1089,7 +1089,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == N);
 
@@ -1139,7 +1139,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1153,7 +1153,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1161,7 +1161,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == N*W);
 
@@ -1228,7 +1228,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1294,7 +1294,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
 
     lfs_size_t total_weight = 0;
@@ -1377,7 +1377,7 @@ code = '''
     lfsr_btree_pop(&lfs, &btree, 0) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 0);
 
@@ -1394,7 +1394,7 @@ code = '''
             LFSR_DATA_BUF("A", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -1433,7 +1433,7 @@ code = '''
     lfsr_btree_pop(&lfs, &btree, 1) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -1456,7 +1456,7 @@ code = '''
             LFSR_DATA_BUF("B", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 2);
 
@@ -1501,7 +1501,7 @@ code = '''
     lfsr_btree_pop(&lfs, &btree, 0) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -1524,7 +1524,7 @@ code = '''
             LFSR_DATA_BUF("A", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 2);
 
@@ -1571,7 +1571,7 @@ code = '''
     lfsr_btree_pop(&lfs, &btree, 2) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 2);
 
@@ -1600,7 +1600,7 @@ code = '''
             LFSR_DATA_BUF("C", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 3);
 
@@ -1654,7 +1654,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1667,7 +1667,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1676,7 +1676,7 @@ code = '''
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == REMAINING);
 
@@ -1746,7 +1746,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1759,7 +1759,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1767,7 +1767,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == REMAINING);
 
@@ -1839,7 +1839,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1887,7 +1887,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == sim_size);
 
@@ -1938,7 +1938,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1951,7 +1951,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -1959,7 +1959,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == REMAINING*W);
 
@@ -2079,7 +2079,7 @@ code = '''
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
                     btree.weight,
-                    btree.block,
+                    btree.blocks[0],
                     btree.trunk);
             return;
         }
@@ -2136,7 +2136,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
 
     lfs_size_t total_weight = 0;
@@ -2228,7 +2228,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == n);
 
@@ -2318,7 +2318,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == sim_size);
 
@@ -2377,7 +2377,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == n*W);
 
@@ -2518,7 +2518,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
 
     lfs_size_t total_weight = 0;
@@ -2621,7 +2621,7 @@ code = '''
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -2687,7 +2687,7 @@ code = '''
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -2748,7 +2748,7 @@ code = '''
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -2818,7 +2818,7 @@ code = '''
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -2932,7 +2932,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == sim_size);
 
@@ -3074,7 +3074,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
 
     lfs_size_t total_weight = 0;
@@ -3150,7 +3150,7 @@ code = '''
     lfsr_btree_alloc(&lfs, &btree) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 0);
 
@@ -3188,7 +3188,7 @@ code = '''
             LFSR_ATTR(0, DATA, 0, BUF("0", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 1);
 
@@ -3244,7 +3244,7 @@ code = '''
             LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 2);
 
@@ -3312,7 +3312,7 @@ code = '''
             LFSR_TAG_DATA, 1, LFSR_DATA_BUF("2", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 3);
 
@@ -3388,7 +3388,7 @@ code = '''
             LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == 3);
 
@@ -3478,7 +3478,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == n);
 
@@ -3593,7 +3593,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == sim_size);
 
@@ -3665,7 +3665,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == n*W);
 
@@ -3808,7 +3808,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
 
     lfs_size_t total_weight = 0;
@@ -3991,7 +3991,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == sim_size);
 
@@ -4193,7 +4193,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
 
     lfs_size_t total_weight = 0;
@@ -4264,7 +4264,7 @@ code = '''
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == n);
 
@@ -4306,10 +4306,11 @@ code = '''
                     binfo.bid,
                     binfo.tag,
                     binfo.weight,
-                    binfo.u.rbyd.block, binfo.u.rbyd.trunk);
+                    binfo.u.rbyd.blocks[0], binfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[binfo.u.rbyd.block / 8] |= 1 << (binfo.u.rbyd.block % 8);
+            seen[binfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (binfo.u.rbyd.blocks[0] % 8);
 
         } else if (binfo.tag == LFSR_TAG_DATA) {
             printf("traversal: %d 0x%x w%d data %d\n",
@@ -4417,7 +4418,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == sim_size);
 
@@ -4458,10 +4459,11 @@ code = '''
                     binfo.bid,
                     binfo.tag,
                     binfo.weight,
-                    binfo.u.rbyd.block, binfo.u.rbyd.trunk);
+                    binfo.u.rbyd.blocks[0], binfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[binfo.u.rbyd.block / 8] |= 1 << (binfo.u.rbyd.block % 8);
+            seen[binfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (binfo.u.rbyd.blocks[0] % 8);
 
         } else if (binfo.tag == LFSR_TAG_DATA) {
             printf("traversal: %d 0x%x w%d data %d\n",
@@ -4506,7 +4508,7 @@ code = '''
     printf("]\n");
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
-            btree.block,
+            btree.blocks[0],
             btree.trunk);
     assert(btree.weight == sim_size);
 
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index 54843fbd..b5356437 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -81,7 +81,7 @@ code = '''
 
     for (lfs_size_t i = 0; i < N; i++) {
         // force mroot to compact
-        lfs.mroot.u.rbyd.eoff = -1;
+        lfs.mroot.rbyd.eoff = -1;
 
         lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
                 LFSR_ATTR(-1, UATTR(i), 0, BUF(&alphas[i % 26], 1)))) => 0;
@@ -178,13 +178,13 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -194,7 +194,7 @@ code = '''
     // assert that our entry is still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -209,7 +209,7 @@ code = '''
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -218,7 +218,7 @@ code = '''
 
     // assert that our entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -251,24 +251,24 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our entries are still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "a", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
@@ -282,17 +282,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "a", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
@@ -324,31 +324,31 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // now add another large entry to the mdir, forcing a split
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -357,13 +357,13 @@ code = '''
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
@@ -376,7 +376,7 @@ code = '''
     // assert mdir was split correctly
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -385,13 +385,13 @@ code = '''
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
@@ -425,8 +425,8 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.u.rbyd.eoff = -1;
-            lfs.mroot.u.rbyd.eoff = -1;
+            mdir.rbyd.eoff = -1;
+            lfs.mroot.rbyd.eoff = -1;
         }
 
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -450,7 +450,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -476,7 +476,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -522,12 +522,12 @@ code = '''
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
         // limit our mid to our mdir's weight
         mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1)
-                + (mdir.mid % (mdir.u.rbyd.weight+1));
+                + (mdir.mid % (mdir.rbyd.weight+1));
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.u.rbyd.eoff = -1;
-            lfs.mroot.u.rbyd.eoff = -1;
+            mdir.rbyd.eoff = -1;
+            lfs.mroot.rbyd.eoff = -1;
         }
 
         // add to rbyd, potentially splitting the mdir
@@ -554,7 +554,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -584,7 +584,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -629,18 +629,18 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // remove the entry, forcing the mdir to be dropped
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(0, RM, -1, NULL()))) => 0;
@@ -648,7 +648,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -664,7 +664,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -698,21 +698,21 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // remove the entry, forcing the mdir to be dropped
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     // force mdir to compact while we're removing
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
 
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(0, RM, -1, NULL()))) => 0;
@@ -720,7 +720,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -736,7 +736,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -770,7 +770,7 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
 
     // remove the entry as we compact, forcing the mdir to be dropped
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -779,7 +779,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -795,7 +795,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -829,7 +829,7 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
 
     // remove the left entry as we compact, forcing the left
     // mdir to be dropped
@@ -839,12 +839,12 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that one entry is still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -859,11 +859,11 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that one entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -896,7 +896,7 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
 
     // remove the right entry as we compact, forcing the right mdir
     // to be dropped
@@ -906,12 +906,12 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that one entry is still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -926,11 +926,11 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that one entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -963,7 +963,7 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
 
     // remove both entries as we compact, forcing both mdirs to be dropped
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -973,7 +973,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     lfsr_unmount(&lfs) => 0;
 
@@ -984,7 +984,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     lfsr_unmount(&lfs) => 0;
 '''
@@ -1013,25 +1013,25 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // now add another large entry to the mdir, forcing a split
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
 
     // remove the left entry as we compact, forcing the left
     // mdir to be dropped
@@ -1042,7 +1042,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -1051,7 +1051,7 @@ code = '''
 
     // assert that one entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -1066,7 +1066,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -1075,7 +1075,7 @@ code = '''
 
     // assert that one entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -1108,25 +1108,25 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // now add another large entry to the mdir, forcing a split
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
 
     // remove the right entry as we compact, forcing the right
     // mdir to be dropped
@@ -1136,7 +1136,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -1145,7 +1145,7 @@ code = '''
 
     // assert that one entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -1160,7 +1160,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -1169,7 +1169,7 @@ code = '''
 
     // assert that one entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -1202,25 +1202,25 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // now add another large entry to the mdir, forcing a split
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
 
     // remove both entries as we compact, forcing both mdirs to be dropped
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -1230,7 +1230,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -1246,7 +1246,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -1301,12 +1301,12 @@ code = '''
                 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
 
         // drop should make sure we never have empty mdirs
-        assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0);
+        assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0);
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.u.rbyd.eoff = -1;
-            lfs.mroot.u.rbyd.eoff = -1;
+            mdir.rbyd.eoff = -1;
+            lfs.mroot.rbyd.eoff = -1;
         }
 
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -1322,7 +1322,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -1348,7 +1348,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -1410,7 +1410,7 @@ code = '''
                 mid += lfsr_mweight(&lfs)) {
             lfsr_mdir_t mdir;
             lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-            for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+            for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                     mdir.mid += 1) {
                 uint8_t buffer[4];
                 lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -1428,12 +1428,12 @@ code = '''
                     0*lfsr_mweight(&lfs)+0, &mdir) => 0;
 
             // drop should make sure we never have empty mdirs
-            assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0);
+            assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0);
 
             // force a compaction?
             if (FORCE_COMPACTION) {
-                mdir.u.rbyd.eoff = -1;
-                lfs.mroot.u.rbyd.eoff = -1;
+                mdir.rbyd.eoff = -1;
+                lfs.mroot.rbyd.eoff = -1;
             }
 
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -1449,7 +1449,7 @@ code = '''
                 mid += lfsr_mweight(&lfs)) {
             lfsr_mdir_t mdir;
             lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-            for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+            for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                     mdir.mid += 1) {
                 uint8_t buffer[4];
                 lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -1476,7 +1476,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -1521,18 +1521,18 @@ code = '''
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
         // limit our mid to our mdir's weight
         mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1)
-                + (mdir.mid % (mdir.u.rbyd.weight+1));
+                + (mdir.mid % (mdir.rbyd.weight+1));
         // choose to create or delete, note we make sure to never delete to zero
-        uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) == mdir.u.rbyd.weight
-                    || (lfsr_mdir_rid(&lfs, &mdir) == mdir.u.rbyd.weight-1
+        uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) == mdir.rbyd.weight
+                    || (lfsr_mdir_rid(&lfs, &mdir) == mdir.rbyd.weight-1
                         && lfsr_mtree_weight(&lfs) == lfsr_mweight(&lfs))
                 ? 0
                 : TEST_PRNG(&prng) % 2);
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.u.rbyd.eoff = -1;
-            lfs.mroot.u.rbyd.eoff = -1;
+            mdir.rbyd.eoff = -1;
+            lfs.mroot.rbyd.eoff = -1;
         }
 
         // create
@@ -1571,9 +1571,9 @@ code = '''
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
 
         // drop should make sure we never have empty mdirs
-        assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0);
+        assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0);
 
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -1605,9 +1605,9 @@ code = '''
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
 
         // drop should make sure we never have empty mdirs
-        assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0);
+        assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0);
 
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -1655,24 +1655,24 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mtree has one mdir
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // force mdir to compact twice, this should relocate
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_t old_mdir = mdir;
 
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0;
@@ -1687,7 +1687,7 @@ code = '''
 
     // assert that our entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -1702,7 +1702,7 @@ code = '''
     // assert mtree has one mdir
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
@@ -1714,7 +1714,7 @@ code = '''
 
     // assert that our entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -1749,24 +1749,24 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // force mdir to compact twice, this should relocate
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_t old_mdir = mdir;
 
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0;
@@ -1776,13 +1776,13 @@ code = '''
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
@@ -1796,20 +1796,20 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
@@ -1843,24 +1843,24 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // force mdir to compact twice, this should relocate
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_t old_mdir = mdir;
 
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0;
@@ -1870,13 +1870,13 @@ code = '''
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "a", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
@@ -1890,20 +1890,20 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "a", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
@@ -1935,9 +1935,9 @@ code = '''
     // force mroot to compact twice, this should extend the mroot
     lfsr_mdir_t old_mroot = lfs.mroot;
 
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     memset(buffer, 'b', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0;
@@ -1995,10 +1995,10 @@ code = '''
     lfsr_mdir_t old_mroot = lfs.mroot;
 
     for (int i = 0; i < 4; i++) {
-        lfs.mroot.u.rbyd.eoff = -1;
+        lfs.mroot.rbyd.eoff = -1;
         lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
     }
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     memset(buffer, 'b', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0;
@@ -2052,9 +2052,9 @@ code = '''
     // force mroot to compact twice, this should extend the mroot
     lfsr_mdir_t old_mroot = lfs.mroot;
 
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert we relocated
@@ -2063,9 +2063,9 @@ code = '''
     // force mroot to compact twice again, this should relocate the mroot
     old_mroot = lfs.mroot;
 
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     memset(buffer, 'b', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0;
@@ -2122,29 +2122,29 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mtree has one mdir
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // setup mroot to need to compact, this should trigger a relocation when
     // we relocate the mdir below
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_t old_mroot = lfs.mroot;
 
     // force mdir to compact twice, this should relocate
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_t old_mdir = mdir;
 
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0;
@@ -2162,7 +2162,7 @@ code = '''
 
     // assert that our entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -2177,7 +2177,7 @@ code = '''
     // assert mtree has one mdir
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mdir
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
@@ -2192,7 +2192,7 @@ code = '''
 
     // assert that our entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -2227,36 +2227,36 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // setup mroot to need to compact, this should trigger a relocation when
     // we relocate the mdir below
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_t old_mroot = lfs.mroot;
 
     // now add another large entry to the mdir, forcing a split
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mroot
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2268,13 +2268,13 @@ code = '''
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
@@ -2288,7 +2288,7 @@ code = '''
     // assert mdir was split correctly
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mroot
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2300,13 +2300,13 @@ code = '''
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
@@ -2340,23 +2340,23 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // setup mroot to need to compact, this should trigger a relocation when
     // we relocate the mdir below
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_t old_mroot = lfs.mroot;
 
     // remove the entry, forcing the mdir to be dropped
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, RM, -1, NULL()))) => 0;
@@ -2364,7 +2364,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mroot
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2383,7 +2383,7 @@ code = '''
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mroot
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2413,7 +2413,7 @@ code = '''
 
     // force mroot to compact once, so the second compact below will trigger
     // a relocation
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // prepare mroot with a large attr so the next entry can not fit
@@ -2429,13 +2429,13 @@ code = '''
 
     // force mroot to compact, this should trigger a relocation
     lfsr_mdir_t old_mroot = lfs.mroot;
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mroot
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2448,7 +2448,7 @@ code = '''
     // assert that our entry is still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -2463,7 +2463,7 @@ code = '''
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mroot
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2475,7 +2475,7 @@ code = '''
 
     // assert that our entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -2501,7 +2501,7 @@ code = '''
 
     // force mroot to compact once, so the second compact below will trigger
     // a relocation
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // create 2 large entries that needs to be uninlined and split
@@ -2516,13 +2516,13 @@ code = '''
 
     // force mroot to compact, this should trigger a relocation
     lfsr_mdir_t old_mroot = lfs.mroot;
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mroot
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2530,13 +2530,13 @@ code = '''
     // assert that our entries are still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "a", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
@@ -2550,20 +2550,20 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert we relocated our mroot
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "a", 1) == 0);
 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
@@ -2604,18 +2604,18 @@ code = '''
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
         // limit our mid to our mdir's weight
         mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1)
-                + (mdir.mid % (mdir.u.rbyd.weight+1));
+                + (mdir.mid % (mdir.rbyd.weight+1));
         // choose to create or delete, note we make sure to never delete to zero
-        uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) == mdir.u.rbyd.weight
-                    || (lfsr_mdir_rid(&lfs, &mdir) == mdir.u.rbyd.weight-1
+        uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) == mdir.rbyd.weight
+                    || (lfsr_mdir_rid(&lfs, &mdir) == mdir.rbyd.weight-1
                         && lfsr_mtree_weight(&lfs) == lfsr_mweight(&lfs))
                 ? 0
                 : TEST_PRNG(&prng) % 3);
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.u.rbyd.eoff = -1;
-            lfs.mroot.u.rbyd.eoff = -1;
+            mdir.rbyd.eoff = -1;
+            lfs.mroot.rbyd.eoff = -1;
         }
 
         // create
@@ -2667,9 +2667,9 @@ code = '''
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
 
         // drop should make sure we never have empty mdirs
-        assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0);
+        assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0);
 
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -2701,9 +2701,9 @@ code = '''
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
 
         // drop should make sure we never have empty mdirs
-        assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0);
+        assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0);
 
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -2742,9 +2742,9 @@ code = '''
     assert(lfsr_mtree_ismptr(&lfs));
 
     lfsr_openedmdir_t left_neighbor  = {
-            .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}};
     lfsr_openedmdir_t right_neighbor = {
-            .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}};
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
@@ -2753,7 +2753,7 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF("c", 1)))) => 0;
 
     // assert that our entry is still in the mtree
-    assert(lfs.mroot.u.rbyd.weight == 3);
+    assert(lfs.mroot.rbyd.weight == 3);
 
     uint8_t buffer[1];
     lfsr_mdir_get(&lfs, &lfs.mroot, 1, LFSR_TAG_REG,
@@ -2762,11 +2762,11 @@ code = '''
 
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0);
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir,
-            sizeof(lfs.mroot.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &lfs.mroot.rbyd,
+            sizeof(lfs.mroot.rbyd)) == 0);
     assert(right_neighbor.mdir.mid == 2);
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir,
-            sizeof(lfs.mroot.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &lfs.mroot.rbyd,
+            sizeof(lfs.mroot.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -2792,9 +2792,9 @@ code = '''
     assert(lfsr_mtree_ismptr(&lfs));
 
     lfsr_openedmdir_t left_neighbor  = {
-            .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}};
     lfsr_openedmdir_t right_neighbor = {
-            .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}};
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
@@ -2803,13 +2803,13 @@ code = '''
             LFSR_ATTR(0, RM, -1, NULL()))) => 0;
 
     // assert that an entry was removed
-    assert(lfs.mroot.u.rbyd.weight == 1);
+    assert(lfs.mroot.rbyd.weight == 1);
 
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == -1);
     assert(right_neighbor.mdir.mid == 0);
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir,
-            sizeof(lfs.mroot.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &lfs.mroot.rbyd,
+            sizeof(lfs.mroot.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -2835,9 +2835,9 @@ code = '''
     assert(lfsr_mtree_ismptr(&lfs));
 
     lfsr_openedmdir_t left_neighbor  = {
-            .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}};
     lfsr_openedmdir_t right_neighbor = {
-            .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}};
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
@@ -2846,12 +2846,12 @@ code = '''
             LFSR_ATTR(1, RM, -1, NULL()))) => 0;
 
     // assert that an entry was removed
-    assert(lfs.mroot.u.rbyd.weight == 1);
+    assert(lfs.mroot.rbyd.weight == 1);
 
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0);
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir,
-            sizeof(lfs.mroot.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &lfs.mroot.rbyd,
+            sizeof(lfs.mroot.rbyd)) == 0);
     assert(right_neighbor.mdir.mid == -1);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
@@ -2880,9 +2880,9 @@ code = '''
     assert(lfsr_mtree_ismptr(&lfs));
 
     lfsr_openedmdir_t left_neighbor  = {
-            .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}};
     lfsr_openedmdir_t right_neighbor = {
-            .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}};
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
@@ -2898,13 +2898,13 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -2914,7 +2914,7 @@ code = '''
     // assert that our entry is still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 2);
+    assert(mdir.rbyd.weight == 2);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "d", 1) == 0);
@@ -2924,15 +2924,15 @@ code = '''
     lfsr_mdir_t msibling;
     lfsr_mtree_lookup(&lfs,
             1*lfsr_mweight(&lfs)+0, &msibling) => 0;
-    assert(msibling.u.rbyd.weight == 1);
+    assert(msibling.rbyd.weight == 1);
 
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0);
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
     assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+0);
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &msibling.u.mdir,
-            sizeof(msibling.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &msibling.rbyd,
+            sizeof(msibling.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -2960,9 +2960,9 @@ code = '''
     assert(lfsr_mtree_ismptr(&lfs));
 
     lfsr_openedmdir_t left_neighbor  = {
-            .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}};
     lfsr_openedmdir_t right_neighbor = {
-            .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}};
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
@@ -2977,18 +2977,18 @@ code = '''
             LFSR_ATTR(2, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our entries are still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 2);
+    assert(mdir.rbyd.weight == 2);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "c", 1) == 0);
@@ -2996,18 +2996,18 @@ code = '''
     lfsr_mdir_t msibling;
     lfsr_mtree_lookup(&lfs,
             1*lfsr_mweight(&lfs)+0, &msibling) => 0;
-    assert(msibling.u.rbyd.weight == 2);
+    assert(msibling.rbyd.weight == 2);
     lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "d", 1) == 0);
 
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0);
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
     assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+1);
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &msibling.u.mdir,
-            sizeof(msibling.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &msibling.rbyd,
+            sizeof(msibling.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -3038,13 +3038,13 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // setup our neighbors
     //
@@ -3052,19 +3052,19 @@ code = '''
     // aggresively split the mtree if there are already neighbors in the mdir
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid+0, REG, +1, BUF("a", 1)),
             LFSR_ATTR(mdir.mid+2, REG, +1, BUF("b", 1)))) => 0;
     // this test only works if these all fit in the mdir
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
-    assert(mdir.u.rbyd.weight == 3);
+    assert(mdir.rbyd.weight == 3);
 
     lfsr_openedmdir_t left_neighbor  = {
-            .mdir={.mid=mdir.mid+0, .u.mdir=mdir.u.mdir}};
+            .mdir={.mid=mdir.mid+0, .rbyd=mdir.rbyd}};
     lfsr_openedmdir_t right_neighbor = {
-            .mdir={.mid=mdir.mid+2, .u.mdir=mdir.u.mdir}};
+            .mdir={.mid=mdir.mid+2, .rbyd=mdir.rbyd}};
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
@@ -3075,13 +3075,13 @@ code = '''
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot still has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -3090,7 +3090,7 @@ code = '''
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 2);
+    assert(mdir.rbyd.weight == 2);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "d", 1) == 0);
@@ -3098,18 +3098,18 @@ code = '''
     lfsr_mdir_t msibling;
     lfsr_mtree_lookup(&lfs,
             1*lfsr_mweight(&lfs)+0, &msibling) => 0;
-    assert(msibling.u.rbyd.weight == 2);
+    assert(msibling.rbyd.weight == 2);
     lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "e", 1) == 0);
 
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0);
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
     assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+1);
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &msibling.u.mdir,
-            sizeof(msibling.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &msibling.rbyd,
+            sizeof(msibling.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -3139,9 +3139,9 @@ code = '''
     assert(lfsr_mtree_ismptr(&lfs));
 
     lfsr_openedmdir_t left_neighbor  = {
-            .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}};
     lfsr_openedmdir_t right_neighbor = {
-            .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}};
+            .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}};
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
@@ -3154,9 +3154,9 @@ code = '''
     // force mroot to compact twice, this should extend the mroot
     lfsr_mdir_t old_mroot = lfs.mroot;
 
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     memset(buffer, 'b', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0;
@@ -3171,11 +3171,11 @@ code = '''
 
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0);
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir,
-            sizeof(lfs.mroot.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &lfs.mroot.rbyd,
+            sizeof(lfs.mroot.rbyd)) == 0);
     assert(right_neighbor.mdir.mid == 1);
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir,
-            sizeof(lfs.mroot.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &lfs.mroot.rbyd,
+            sizeof(lfs.mroot.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -3208,13 +3208,13 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // setup our neighbors
     //
@@ -3222,28 +3222,28 @@ code = '''
     // aggresively split the mtree if there are already neighbors in the mdir
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid+0, REG, +1, BUF("a", 1)),
             LFSR_ATTR(mdir.mid+2, REG, +1, BUF("b", 1)))) => 0;
     // this test only works if these all fit in the mdir
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
-    assert(mdir.u.rbyd.weight == 3);
+    assert(mdir.rbyd.weight == 3);
 
     lfsr_openedmdir_t left_neighbor  = {
-            .mdir={.mid=mdir.mid+0, .u.mdir=mdir.u.mdir}};
+            .mdir={.mid=mdir.mid+0, .rbyd=mdir.rbyd}};
     lfsr_openedmdir_t right_neighbor = {
-            .mdir={.mid=mdir.mid+2, .u.mdir=mdir.u.mdir}};
+            .mdir={.mid=mdir.mid+2, .rbyd=mdir.rbyd}};
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
     // force mdir to compact twice, this should relocate
     lfsr_mdir_t old_mdir = mdir;
 
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     memset(buffer, 'e', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(1, REG, 0, BUF(buffer, SIZE)))) => 0;
@@ -3258,7 +3258,7 @@ code = '''
 
     // assert that our entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 3);
+    assert(mdir.rbyd.weight == 3);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -3266,11 +3266,11 @@ code = '''
 
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0);
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
     assert(right_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+2);
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -3304,7 +3304,7 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // we should now have 2 mdirs
@@ -3313,13 +3313,13 @@ code = '''
     // now force one of our siblings to split
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // we should now have 3 mdirs
@@ -3332,25 +3332,25 @@ code = '''
     lfsr_openedmdir_t left_neighbor;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0,
             &left_neighbor.mdir) => 0;
-    assert(left_neighbor.mdir.u.rbyd.weight == 1);
+    assert(left_neighbor.mdir.rbyd.weight == 1);
 
     lfsr_openedmdir_t right_neighbor;
     lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0,
             &right_neighbor.mdir) => 0;
-    assert(right_neighbor.mdir.u.rbyd.weight == 1);
+    assert(right_neighbor.mdir.rbyd.weight == 1);
 
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
     // cause middle mdir to split
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     memset(buffer, 'd', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // we should now have 4 mdirs
@@ -3359,13 +3359,13 @@ code = '''
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0);
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
 
     assert(right_neighbor.mdir.mid == 3*lfsr_mweight(&lfs)+0);
     lfsr_mtree_lookup(&lfs, 3*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -3399,7 +3399,7 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // we should now have 2 mdirs
@@ -3408,13 +3408,13 @@ code = '''
     // now force one of our siblings to split
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     memset(buffer, 'c', SIZE);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mdir to compact
-    mdir.u.rbyd.eoff = -1;
+    mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0;
 
     // we should now have 3 mdirs
@@ -3427,19 +3427,19 @@ code = '''
     lfsr_openedmdir_t left_neighbor;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0,
             &left_neighbor.mdir) => 0;
-    assert(left_neighbor.mdir.u.rbyd.weight == 1);
+    assert(left_neighbor.mdir.rbyd.weight == 1);
 
     lfsr_openedmdir_t right_neighbor;
     lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0,
             &right_neighbor.mdir) => 0;
-    assert(right_neighbor.mdir.u.rbyd.weight == 1);
+    assert(right_neighbor.mdir.rbyd.weight == 1);
 
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
 
     // cause middle mdir to drop 
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(mdir.mid, RM, -1, NULL()))) => 0;
 
@@ -3449,13 +3449,13 @@ code = '''
     // assert that our neighbors were updated correctly
     assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0);
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
 
     assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+0);
     lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(memcmp(&right_neighbor.mdir.u.mdir, &mdir.u.mdir,
-            sizeof(mdir.u.mdir)) == 0);
+    assert(memcmp(&right_neighbor.mdir.rbyd, &mdir.rbyd,
+            sizeof(mdir.rbyd)) == 0);
 
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor);
     lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor);
@@ -3483,7 +3483,7 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF("a", 1)))) => 0;
 
     // assert that our entry is still in the mtree
-    assert(lfs.mroot.u.rbyd.weight == 1);
+    assert(lfs.mroot.rbyd.weight == 1);
 
     uint8_t buffer[1];
     lfsr_mdir_get(&lfs, &lfs.mroot, 0, LFSR_TAG_REG,
@@ -3510,22 +3510,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else {
             // this shouldn't happen
@@ -3548,7 +3549,7 @@ code = '''
     // and the tree should still work
 
     // assert that our entry is still in the mtree
-    assert(lfs.mroot.u.rbyd.weight == 1);
+    assert(lfs.mroot.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &lfs.mroot, 0, LFSR_TAG_REG,
             buffer, 1) => 1;
@@ -3583,13 +3584,13 @@ code = '''
             LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -3599,7 +3600,7 @@ code = '''
     // assert that our entry is still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -3625,22 +3626,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else {
             // this shouldn't happen
@@ -3665,7 +3667,7 @@ code = '''
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our attr is still in the mroot
     lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),
@@ -3674,7 +3676,7 @@ code = '''
 
     // assert that our entry is still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
 
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
@@ -3708,18 +3710,18 @@ code = '''
             LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our entries are still in the mtree
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "a", 1) == 0);
@@ -3727,7 +3729,7 @@ code = '''
     lfsr_mdir_t msibling;
     lfsr_mtree_lookup(&lfs,
             1*lfsr_mweight(&lfs)+0, &msibling) => 0;
-    assert(msibling.u.rbyd.weight == 1);
+    assert(msibling.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
@@ -3752,22 +3754,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else {
             // this shouldn't happen
@@ -3792,18 +3795,18 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs));
     // assert mroot now has no entries
-    assert(lfs.mroot.u.rbyd.weight == 0);
+    assert(lfs.mroot.rbyd.weight == 0);
 
     // assert that our entries are still in the mtree
     lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0;
-    assert(mdir.u.rbyd.weight == 1);
+    assert(mdir.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "a", 1) == 0);
 
     lfsr_mtree_lookup(&lfs,
             1*lfsr_mweight(&lfs)+0, &msibling) => 0;
-    assert(msibling.u.rbyd.weight == 1);
+    assert(msibling.rbyd.weight == 1);
     lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG,
             buffer, SIZE) => SIZE;
     assert(memcmp(buffer, "b", 1) == 0);
@@ -3836,9 +3839,9 @@ code = '''
     // force mroot to compact twice, this should extend the mroot
     lfsr_mdir_t old_mroot = lfs.mroot;
 
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     memset(buffer, 'b', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0;
@@ -3871,22 +3874,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else {
             // this shouldn't happen
@@ -3945,8 +3949,8 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.u.rbyd.eoff = -1;
-            lfs.mroot.u.rbyd.eoff = -1;
+            mdir.rbyd.eoff = -1;
+            lfs.mroot.rbyd.eoff = -1;
         }
 
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -3970,7 +3974,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -4001,22 +4005,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else {
             // this shouldn't happen
@@ -4047,7 +4052,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -4093,12 +4098,12 @@ code = '''
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
         // limit our mid to our mdir's weight
         mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1)
-                + (mdir.mid % (mdir.u.rbyd.weight+1));
+                + (mdir.mid % (mdir.rbyd.weight+1));
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.u.rbyd.eoff = -1;
-            lfs.mroot.u.rbyd.eoff = -1;
+            mdir.rbyd.eoff = -1;
+            lfs.mroot.rbyd.eoff = -1;
         }
 
         // add to rbyd, potentially splitting the mdir
@@ -4125,7 +4130,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -4160,22 +4165,23 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
             // keep track of seen blocks
-            seen[tinfo.u.mdir.u.mdir.blocks[1] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8);
-            seen[tinfo.u.mdir.u.mdir.blocks[0] / 8]
-                    |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[1] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8);
+            seen[tinfo.u.mdir.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
             // keep track of seen blocks
-            seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8);
+            seen[tinfo.u.rbyd.blocks[0] / 8]
+                    |= 1 << (tinfo.u.rbyd.blocks[0] % 8);
 
         } else {
             // this shouldn't happen
@@ -4207,7 +4213,7 @@ code = '''
             mid += lfsr_mweight(&lfs)) {
         lfsr_mdir_t mdir;
         lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
-        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight;
+        for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight;
                 mdir.mid += 1) {
             uint8_t buffer[4];
             lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,
@@ -4257,13 +4263,13 @@ code = '''
         if (tinfo.tag == LFSR_TAG_MDIR) {
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tinfo.tag,
-                    tinfo.u.mdir.u.mdir.blocks[0],
-                    tinfo.u.mdir.u.mdir.blocks[1]);
+                    tinfo.u.mdir.rbyd.blocks[0],
+                    tinfo.u.mdir.rbyd.blocks[1]);
 
         } else if (tinfo.tag == LFSR_TAG_BRANCH) {
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tinfo.tag,
-                    tinfo.u.rbyd.block, tinfo.u.rbyd.trunk);
+                    tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk);
 
         } else {
             // this shouldn't happen
@@ -4319,9 +4325,9 @@ code = '''
     // force mroot to compact twice, this should extend the mroot
     lfsr_mdir_t old_mroot = lfs.mroot;
 
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     memset(buffer, 'b', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0;
@@ -4374,10 +4380,10 @@ code = '''
     lfsr_mdir_t old_mroot = lfs.mroot;
 
     for (int i = 0; i < 4; i++) {
-        lfs.mroot.u.rbyd.eoff = -1;
+        lfs.mroot.rbyd.eoff = -1;
         lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
     }
-    lfs.mroot.u.rbyd.eoff = -1;
+    lfs.mroot.rbyd.eoff = -1;
     memset(buffer, 'b', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0;
diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml
index 8c3fa8a3..47b6c14a 100644
--- a/tests/test_rbyd.toml
+++ b/tests/test_rbyd.toml
@@ -36,7 +36,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -46,18 +46,18 @@ code = '''
 
     // commit with one attribute
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 
     // commit with two attributes
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 '''
 
 [cases.test_rbyd_multi_commit]
@@ -67,7 +67,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -77,19 +77,19 @@ code = '''
 
     // commit with one attribute
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 
     // commit with two attributes
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 '''
 
 [cases.test_rbyd_commit_fetch_commit]
@@ -99,7 +99,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -109,15 +109,15 @@ code = '''
 
     // commit with one attribute
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 
     // commit with the second attribute
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 '''
 
 # [cases.test_rbyd_fetchmatch]
@@ -132,7 +132,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -145,7 +145,7 @@ code = '''
 
     // commit with one attribute
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -157,7 +157,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -168,7 +168,7 @@ code = '''
 
     // commit with two attributes
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -186,7 +186,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -202,7 +202,7 @@ code = '''
 
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
@@ -220,7 +220,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -242,7 +242,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -255,7 +255,7 @@ code = '''
 
     // commit with one attribute
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -267,7 +267,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -278,7 +278,7 @@ code = '''
 
     // commit with two attributes
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -297,7 +297,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -313,7 +313,7 @@ code = '''
 
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -332,7 +332,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -354,7 +354,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -365,7 +365,7 @@ code = '''
 
     // commit with one attribute
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -375,7 +375,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -384,7 +384,7 @@ code = '''
 
     // commit with two attributes
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -396,7 +396,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => 4;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
@@ -406,7 +406,7 @@ code = '''
 
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
@@ -417,7 +417,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => 4;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
@@ -433,7 +433,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -444,7 +444,7 @@ code = '''
 
     // commit with one attribute
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -454,7 +454,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -463,7 +463,7 @@ code = '''
 
     // commit with two attributes
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -476,7 +476,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => 4;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
@@ -486,7 +486,7 @@ code = '''
 
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -498,7 +498,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4)
             => 4;
     lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4)
@@ -514,7 +514,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -530,12 +530,12 @@ code = '''
     //    =>  .-'|
     // 1      1  2
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -552,12 +552,12 @@ code = '''
     //    =>  .-'|
     // 2      2  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -577,7 +577,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -593,13 +593,13 @@ code = '''
     // .-'|  =>  .----'|
     // 1  2      1  2  2
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -616,13 +616,13 @@ code = '''
     // .-'|  =>     .-'|
     // 1  2      1  2  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -642,7 +642,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -660,13 +660,13 @@ code = '''
     // .-'|      |  .-'|
     // 1  2      1  2  3
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -690,13 +690,13 @@ code = '''
     // .-'|      .--|-'|
     // 2  3      2  3  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -721,7 +721,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -739,14 +739,14 @@ code = '''
     // |  .-'|      |  .----'|
     // 1  2  3      1  2  3  3
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -770,14 +770,14 @@ code = '''
     // |  .-'|      |     .-'|
     // 1  2  3      1  2  3  2
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -801,14 +801,14 @@ code = '''
     // |  .-'|         .--|-'|
     // 1  2  3      1  2  3  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -832,14 +832,14 @@ code = '''
     // .--|-'|      |     .-'|
     // 3  1  2      3  1  2  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -864,7 +864,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -884,14 +884,14 @@ code = '''
     // |  .-'|      |  |  .-'|
     // 1  2  3      1  2  3  4
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -922,14 +922,14 @@ code = '''
     // |  .-'|      |  .--|-'|      .--|--|-'|
     // 1  3  4      1  3  4  2      1  3  4  2
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -960,14 +960,14 @@ code = '''
     // |  .-'|      .--|--|-'|
     // 2  3  4      2  3  4  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -998,14 +998,14 @@ code = '''
     // .--|-'|      |  .--|-'|
     // 4  2  3      4  2  3  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1035,7 +1035,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -1055,14 +1055,14 @@ code = '''
     // |  .-'|      |  |  .-'|
     // 1  2  3      1  2  3  4
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1093,14 +1093,14 @@ code = '''
     // |  .-'|      |  |  .-'|
     // 1  2  4      1  2  4  3
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1131,14 +1131,14 @@ code = '''
     // |  .-'|      |  |  .-'|      |  .--|-'|
     // 1  4  2      1  4  2  3      1  4  2  3
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1169,14 +1169,14 @@ code = '''
     // |  .-'|      |  |  .-'|      .--|--|-'|
     // 4  1  2      4  1  2  3      4  1  2  3
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1206,7 +1206,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -1228,7 +1228,7 @@ code = '''
     // |  |  .-'|      |  |  .----'|
     // 1  2  3  4      1  2  3  4  4
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1236,7 +1236,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1269,7 +1269,7 @@ code = '''
     // |  |  .-'|      |  |     .-'|
     // 1  2  3  4      1  2  3  4  3
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1277,7 +1277,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1308,7 +1308,7 @@ code = '''
     // |  |  .-'|      |     .-'|  |
     // 1  2  3  4      1  2  3  4  2
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1316,7 +1316,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1347,7 +1347,7 @@ code = '''
     // |  |  .-'|         |  .-'|  |
     // 1  2  3  4      1  2  3  4  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1355,7 +1355,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1385,7 +1385,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -1409,7 +1409,7 @@ code = '''
     // |  |  .-'|      |  |  |  .-'|
     // 1  2  3  4      1  2  3  4  5
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1417,7 +1417,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1457,7 +1457,7 @@ code = '''
     // |  |  .-'|      |  |  .--|-'|
     // 1  2  4  5      1  2  4  5  3
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1465,7 +1465,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1503,7 +1503,7 @@ code = '''
     // |  |  .-'|      |  |  .-'|  |
     // 1  3  4  5      1  3  4  5  2
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
@@ -1511,7 +1511,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1549,7 +1549,7 @@ code = '''
     // |  |  .-'|      |  |  .-'|  |
     // 2  3  4  5      2  3  4  5  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
@@ -1557,7 +1557,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1592,7 +1592,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -1616,7 +1616,7 @@ code = '''
     // |  |  |  .-'|      |  |  |  .----'|
     // 1  2  3  4  5      1  2  3  4  5  5
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1625,7 +1625,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1665,7 +1665,7 @@ code = '''
     // |  |  |  .-'|      |     |  .-'|  |
     // 1  2  3  4  5      1  2  3  4  5  2
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1674,7 +1674,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1714,7 +1714,7 @@ code = '''
     // |  |  |  .-'|         |  |  .-'|  |
     // 1  2  3  4  5      1  2  3  4  5  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1723,7 +1723,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1758,7 +1758,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -1784,7 +1784,7 @@ code = '''
     // |  |  |  .-'|      |  |  |  |  .-'|
     // 1  2  3  4  5      1  2  3  4  5  6
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -1793,7 +1793,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1838,7 +1838,7 @@ code = '''
     // |  |  |  .-'|      |  |  |  .-'|  |
     // 1  3  4  5  6      1  3  4  5  6  2
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
@@ -1847,7 +1847,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1892,7 +1892,7 @@ code = '''
     // |  |  |  .-'|      |  |  |  .-'|  |
     // 2  3  4  5  6      2  3  4  5  6  1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)),
@@ -1901,7 +1901,7 @@ code = '''
             LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -1945,7 +1945,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -1988,10 +1988,10 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1),
                     &rid_, &tag_, NULL, &data_) => 0;
@@ -2035,7 +2035,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2071,14 +2071,14 @@ code = '''
 
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(-1, UATTR(perm[j]+1), 0,
                         BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1),
                     &rid_, &tag_, NULL, &data_) => 0;
@@ -2116,7 +2116,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2131,7 +2131,7 @@ code = '''
     // so that lookups return strictly the tag greater than or equal to
     // the tag requested
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -2149,7 +2149,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2165,7 +2165,7 @@ code = '''
 
     // also try the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
@@ -2183,7 +2183,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2205,7 +2205,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2220,7 +2220,7 @@ code = '''
     // so that lookups return strictly the tag greater than or equal to
     // the tag requested
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -2239,7 +2239,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2255,7 +2255,7 @@ code = '''
 
     // also try the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -2274,7 +2274,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2300,7 +2300,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2339,10 +2339,10 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         // try traversing all tags
         tag_ = 0;
         rid_ = -1;
@@ -2371,7 +2371,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2404,14 +2404,14 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(-1, UATTR(perm[j]+1), 0,
                         BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         // try traversing all tags
         tag_ = 0;
         rid_ = -1;
@@ -2442,7 +2442,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2459,7 +2459,7 @@ code = '''
 
     // create one consistent block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
         lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -2470,7 +2470,7 @@ code = '''
     lfsr_rbyd_t backup_rbyd = rbyd;
     uint8_t *backup_block = malloc(rbyd.eoff);
     lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-            rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+            rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
     // test all permutations of a given size
     size_t perm_count = TEST_FACTORIAL(N);
@@ -2493,9 +2493,9 @@ code = '''
 
         // restore backup
         rbyd = backup_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
         lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
         // update each tag in permutation order
@@ -2506,7 +2506,7 @@ code = '''
         }
 
         // check that all tags have been updated
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1),
                     &rid_, &tag_, NULL, &data_) => 0;
@@ -2552,7 +2552,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2565,7 +2565,7 @@ code = '''
 
     // create the rbyd tree
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     // keep appending tags until we run out of space
     //
@@ -2590,7 +2590,7 @@ code = '''
 
     // check that we can still lookup all the tags
     prng = 42;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     for (lfs_size_t i = 0; i < count; i++) {
         lfs_size_t x
                 = (ORDER == 0) ? i
@@ -2614,7 +2614,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2627,7 +2627,7 @@ code = '''
 
     // add and remove one attribute
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -2638,7 +2638,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
@@ -2646,7 +2646,7 @@ code = '''
 
     // commit with two attributes, remove the first one
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -2666,7 +2666,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -2682,7 +2682,7 @@ code = '''
 
     // commit with two attributes, remove the second one
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -2699,7 +2699,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(1));
@@ -2726,7 +2726,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2762,7 +2762,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(-1, UATTR(perm[j]+1), 0,
@@ -2773,7 +2773,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try removing each tag
         for (unsigned j = 0; j < N; j++) {
@@ -2781,16 +2781,16 @@ code = '''
             printf("--- remove: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(-1, RM(UATTR(j+1)), 0, NULL())))
                     => 0;
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
                 int err = lfsr_rbyd_lookupnext(&lfs, &rbyd,
                         -1, LFSR_TAG_UATTR(k+1),
@@ -2818,7 +2818,7 @@ code = '''
                     LFSR_ATTR(-1, UATTR(j+1), 0,
                         BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_lookupnext(&lfs, &rbyd,
                         -1, LFSR_TAG_UATTR(k+1),
@@ -2875,7 +2875,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2907,7 +2907,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(-1, UATTR(perm[j]+1), 0,
@@ -2918,7 +2918,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try removing each tag
         for (unsigned j = 0; j < N; j++) {
@@ -2926,16 +2926,16 @@ code = '''
             printf("--- remove: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(-1, RM(UATTR(j+1)), 0, NULL()))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
 
             tag_ = 0;
             rid_ = -1;
@@ -2969,7 +2969,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -2982,7 +2982,7 @@ code = '''
 
     // create a tree two attributes
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
@@ -3086,7 +3086,7 @@ code = '''
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
     // one last fetch to make sure nothing was broken
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3118,7 +3118,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -3131,7 +3131,7 @@ code = '''
 
     // create a tree
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -3321,7 +3321,7 @@ code = '''
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
     // one last fetch to make sure nothing was broken
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3353,7 +3353,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -3366,7 +3366,7 @@ code = '''
 
     // commit with one attribute, remove it
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -3377,7 +3377,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
@@ -3385,7 +3385,7 @@ code = '''
 
     // commit with two attributes, remove both
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -3398,7 +3398,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
@@ -3406,7 +3406,7 @@ code = '''
 
     // commit with two attributes, remove both in the other order
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -3419,7 +3419,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2),
@@ -3441,7 +3441,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -3458,7 +3458,7 @@ code = '''
 
     // create one consistent block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
         lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -3469,7 +3469,7 @@ code = '''
     lfsr_rbyd_t backup_rbyd = rbyd;
     uint8_t *backup_block = malloc(rbyd.eoff);
     lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-            rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+            rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
     // test all permutations of a given size
     size_t perm_count = TEST_FACTORIAL(N);
@@ -3492,9 +3492,9 @@ code = '''
 
         // restore backup
         rbyd = backup_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
         lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
         // remove each tag in permutation order
@@ -3504,7 +3504,7 @@ code = '''
         }
 
         // check that all tags are now removed
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1),
                     &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -3515,7 +3515,7 @@ code = '''
                 LFSR_ATTR(-1, UATTR(1), 0,
                     BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
                 &rid_, &tag_, NULL, &data_) => 0;
         assert(tag_ == LFSR_TAG_UATTR(1));
@@ -3564,7 +3564,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -3597,7 +3597,7 @@ code = '''
 
     // set up rbyd block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     prng = SEED;
     for (unsigned i = 0; i < N; i++) {
@@ -3673,7 +3673,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -3684,7 +3684,7 @@ code = '''
 
     // try to create one rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -3692,14 +3692,14 @@ 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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
     // try to create two ids
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -3710,7 +3710,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3719,7 +3719,7 @@ code = '''
 
     // try to create two in the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
@@ -3730,7 +3730,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3739,7 +3739,7 @@ code = '''
 
     // create a third to the right
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -3753,7 +3753,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3764,7 +3764,7 @@ code = '''
 
     // create a third to the left
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)),
@@ -3778,7 +3778,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3789,7 +3789,7 @@ code = '''
 
     // create a third in the middle
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)),
@@ -3803,7 +3803,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3820,7 +3820,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -3831,7 +3831,7 @@ code = '''
 
     // try to create one rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -3840,7 +3840,7 @@ code = '''
             => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -3848,7 +3848,7 @@ code = '''
 
     // try to create two ids
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -3860,7 +3860,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3869,7 +3869,7 @@ code = '''
 
     // try to create two in the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -3881,7 +3881,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3890,7 +3890,7 @@ code = '''
 
     // create a third to the right
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -3906,7 +3906,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3917,7 +3917,7 @@ code = '''
 
     // create a third to the left
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -3933,7 +3933,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3944,7 +3944,7 @@ code = '''
 
     // create a third in the middle
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -3960,7 +3960,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -3981,7 +3981,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4037,10 +4037,10 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
@@ -4082,7 +4082,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4124,7 +4124,7 @@ code = '''
 
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -4138,7 +4138,7 @@ code = '''
                     LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd,
@@ -4175,7 +4175,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4191,7 +4191,7 @@ code = '''
     // so that lookups return strictly the tag greater than or equal to
     // the tag requested
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -4213,7 +4213,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -4233,7 +4233,7 @@ code = '''
 
     // also try the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
@@ -4255,7 +4255,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -4281,7 +4281,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4297,7 +4297,7 @@ code = '''
     // so that lookups return strictly the tag greater than or equal to
     // the tag requested
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -4320,7 +4320,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -4340,7 +4340,7 @@ code = '''
 
     // also try the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -4363,7 +4363,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -4393,7 +4393,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4448,10 +4448,10 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         // try traversing all tags
         tag_ = 0;
@@ -4484,7 +4484,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4525,7 +4525,7 @@ code = '''
 
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -4539,7 +4539,7 @@ code = '''
                     LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         // try traversing all tags
         tag_ = 0;
@@ -4571,7 +4571,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4589,7 +4589,7 @@ code = '''
 
     // create the rbyd tree
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     // keep inserting tags until we run out of space
     //
@@ -4619,7 +4619,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     for (uint16_t x = 0; x < rbyd.weight; x++) {
         lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_REG,
                 &rid_, &tag_, NULL, &data_) => 0;
@@ -4639,7 +4639,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4650,7 +4650,7 @@ code = '''
 
     // try to create one rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)))) => 0;
@@ -4661,7 +4661,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4670,7 +4670,7 @@ code = '''
 
     // try to create two ids
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -4687,7 +4687,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4700,7 +4700,7 @@ code = '''
 
     // try to create two in the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb",         2)),
@@ -4717,7 +4717,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4730,7 +4730,7 @@ code = '''
 
     // create a third to the right
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -4747,7 +4747,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4770,7 +4770,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4787,7 +4787,7 @@ code = '''
 
     // create a third to the left
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb",         2)),
@@ -4810,7 +4810,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4827,7 +4827,7 @@ code = '''
 
     // create a third in the middle
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -4850,7 +4850,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4873,7 +4873,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -4884,7 +4884,7 @@ code = '''
 
     // try to create one rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -4896,7 +4896,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4905,7 +4905,7 @@ code = '''
 
     // try to create two ids
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -4925,7 +4925,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4938,7 +4938,7 @@ code = '''
 
     // try to create two in the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -4958,7 +4958,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -4971,7 +4971,7 @@ code = '''
 
     // create a third to the right
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -4993,7 +4993,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5016,7 +5016,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5033,7 +5033,7 @@ code = '''
 
     // create a third to the left
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -5061,7 +5061,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5078,7 +5078,7 @@ code = '''
 
     // create a third in the middle
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -5106,7 +5106,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 3);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -5134,7 +5134,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -5196,10 +5196,10 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, (1+M)*N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
@@ -5248,7 +5248,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -5290,7 +5290,7 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -5310,7 +5310,7 @@ code = '''
             }
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
@@ -5352,7 +5352,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -5368,7 +5368,7 @@ code = '''
     // so that lookups return strictly the tag greater than or equal to
     // the tag requested
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -5406,7 +5406,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -5440,7 +5440,7 @@ code = '''
 
     // also try the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb",         2)),
@@ -5478,7 +5478,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -5518,7 +5518,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -5534,7 +5534,7 @@ code = '''
     // so that lookups return strictly the tag greater than or equal to
     // the tag requested
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -5575,7 +5575,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -5609,7 +5609,7 @@ code = '''
 
     // also try the other direction
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -5650,7 +5650,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -5695,7 +5695,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -5756,10 +5756,10 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, attrs, (1+M)*N) => 0;
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
         // try traversing all tags
@@ -5805,7 +5805,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -5846,7 +5846,7 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -5866,7 +5866,7 @@ code = '''
             }
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
         // try traversing all tags
@@ -5914,7 +5914,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -5937,7 +5937,7 @@ code = '''
 
     // create one consistent block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
         lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -5953,7 +5953,7 @@ code = '''
     lfsr_rbyd_t backup_rbyd = rbyd;
     uint8_t *backup_block = malloc(rbyd.eoff);
     lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-            rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+            rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
     // test all permutations of a given size
     size_t perm_count = TEST_FACTORIAL(N*M);
@@ -5976,9 +5976,9 @@ code = '''
 
         // restore backup
         rbyd = backup_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
         lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
         // update each tag in permutation order
@@ -5989,7 +5989,7 @@ code = '''
         }
 
         // check that all tags have been updated
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
@@ -6042,7 +6042,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -6087,7 +6087,7 @@ code = '''
 
         // create given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -6111,7 +6111,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try removing each tag
         for (unsigned j = 0; j < N*M; j++) {
@@ -6119,15 +6119,15 @@ code = '''
             printf("--- remove: rid%jd, %jd ---\n", j/M, (j%M)+1);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(j/M, RM(UATTR((j%M)+1)), 0, NULL()))) => 0;
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
@@ -6168,7 +6168,7 @@ code = '''
                     LFSR_ATTR(j/M, UATTR((j%M)+1), 0,
                         BUF(names[(j/M)%6], 3)))) => 0;
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
@@ -6237,7 +6237,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -6260,7 +6260,7 @@ code = '''
 
     // create one consistent block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
         lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -6276,7 +6276,7 @@ code = '''
     lfsr_rbyd_t backup_rbyd = rbyd;
     uint8_t *backup_block = malloc(rbyd.eoff);
     lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-            rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+            rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
     // test all permutations of a given size
     size_t perm_count = TEST_FACTORIAL(N*M);
@@ -6299,9 +6299,9 @@ code = '''
 
         // restore backup
         rbyd = backup_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
         lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
         // remove each tag in permutation order
@@ -6312,7 +6312,7 @@ code = '''
         }
 
         // check that all tags have been removed
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4;
             assert(memcmp(buffer, names[j % 6], 4) == 0);
@@ -6361,7 +6361,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -6379,7 +6379,7 @@ code = '''
 
     // create the rbyd tree
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     // keep inserting tags until we run out of space
     //
@@ -6416,7 +6416,7 @@ code = '''
     lfsr_tag_t tag_;
     lfs_ssize_t rid_;
     lfsr_data_t data_;
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     for (uint16_t x = 0; x < rbyd.weight; x++) {
         lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_REG,
                 &rid_, &tag_, NULL, &data_) => 0;
@@ -6450,7 +6450,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -6492,7 +6492,7 @@ code = '''
 
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -6513,7 +6513,7 @@ code = '''
         }
 
         // try looking up each tag
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd,
@@ -6589,7 +6589,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -6631,7 +6631,7 @@ code = '''
 
         // test the given permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -6657,7 +6657,7 @@ code = '''
         }
 
         // try looking up each tag
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_get(&lfs, &rbyd,
@@ -6745,7 +6745,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -6756,7 +6756,7 @@ code = '''
 
     // try to delete one rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -6768,7 +6768,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0);
@@ -6776,7 +6776,7 @@ code = '''
 
     // try to delete the other rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -6788,7 +6788,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, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4;
     assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0);
@@ -6796,7 +6796,7 @@ code = '''
 
     // try to delete the largest of three
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -6819,7 +6819,7 @@ code = '''
 
     // try to delete the smallest of three
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -6842,7 +6842,7 @@ code = '''
 
     // try to delete the middle
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -6871,7 +6871,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -6882,7 +6882,7 @@ code = '''
 
     // try to delete one rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -6903,7 +6903,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -6918,7 +6918,7 @@ code = '''
 
     // try to delete the other rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -6939,7 +6939,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 1);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -6954,7 +6954,7 @@ code = '''
 
     // try to delete the largest of three
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -6982,7 +6982,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -7003,7 +7003,7 @@ code = '''
 
     // try to delete the smallest of three
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -7032,7 +7032,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -7053,7 +7053,7 @@ code = '''
 
     // try to delete the middle
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -7082,7 +7082,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 2);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => 4;
@@ -7117,7 +7117,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -7159,7 +7159,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
@@ -7179,7 +7179,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try deleting each rid
         for (unsigned j = 0; j < N; j++) {
@@ -7187,16 +7187,16 @@ code = '''
             printf("--- delete: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(j, RM, -1, NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
             for (unsigned k = 0; k < N-1; k++) {
                 lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
@@ -7215,7 +7215,7 @@ code = '''
                     LFSR_ATTR(j, REG, +1, BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -7271,7 +7271,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -7313,7 +7313,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
@@ -7339,7 +7339,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try deleting each rid
         for (unsigned j = 0; j < N; j++) {
@@ -7347,16 +7347,16 @@ code = '''
             printf("--- delete: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(j, RM, -1, NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
             for (unsigned k = 0; k < N-1; k++) {
                 lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
@@ -7392,7 +7392,7 @@ code = '''
             }
             assert(rbyd.weight == N);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -7461,7 +7461,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -7502,7 +7502,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
@@ -7522,7 +7522,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try deleting each rid
         for (unsigned j = 0; j < N; j++) {
@@ -7530,9 +7530,9 @@ code = '''
             printf("--- delete: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -7540,7 +7540,7 @@ code = '''
             assert(rbyd.weight == N-1);
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
 
             tag_ = 0;
@@ -7585,7 +7585,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -7626,7 +7626,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
@@ -7652,7 +7652,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try deleting each rid
         for (unsigned j = 0; j < N; j++) {
@@ -7660,9 +7660,9 @@ code = '''
             printf("--- delete: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -7670,7 +7670,7 @@ code = '''
             assert(rbyd.weight == N-1);
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
 
             tag_ = 0;
@@ -7723,7 +7723,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -7734,7 +7734,7 @@ code = '''
 
     // create and delete one rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -7744,14 +7744,14 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
     // create and delete two ids
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -7763,14 +7763,14 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
     // create and delete two ids in the other order
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
@@ -7782,14 +7782,14 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
     // create and delete three ids
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -7803,14 +7803,14 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
     // create and delete three ids in the other order
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)),
@@ -7824,7 +7824,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -7837,7 +7837,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -7848,7 +7848,7 @@ code = '''
 
     // create and delete one rid
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)))) => 0;
@@ -7859,14 +7859,14 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
     // create and delete two ids
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -7880,14 +7880,14 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
     // create and delete two ids in the other order
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -7901,14 +7901,14 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
     // create and delete three ids
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -7925,14 +7925,14 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
     // create and delete three ids in the other order
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG,    +1, BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa",         2)),
@@ -7949,7 +7949,7 @@ code = '''
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     assert(rbyd.weight == 0);
     lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4)
             => LFS_ERR_NOENT;
@@ -7970,7 +7970,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -7993,7 +7993,7 @@ code = '''
 
     // create one consistent block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
         lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -8005,7 +8005,7 @@ code = '''
     lfsr_rbyd_t backup_rbyd = rbyd;
     uint8_t *backup_block = malloc(rbyd.eoff);
     lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-            rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+            rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
     // test all permutations of a given size
     size_t perm_count = TEST_FACTORIAL(N);
@@ -8028,9 +8028,9 @@ code = '''
 
         // restore backup
         rbyd = backup_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
         lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
         // delete each rid in permutation order
@@ -8050,7 +8050,7 @@ code = '''
         }
 
         // check that all tags are now removed
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 0);
         lfsr_rbyd_get(&lfs, &rbyd,
                 LFSR_TAG_REG, 0, buffer, 4)
@@ -8062,7 +8062,7 @@ code = '''
                     BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
         assert(rbyd.weight == 1);
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 1);
         lfsr_rbyd_get(&lfs, &rbyd,
                 0, LFSR_TAG_REG, buffer, 6)
@@ -8113,7 +8113,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -8136,7 +8136,7 @@ code = '''
 
     // create one consistent block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
         lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -8153,7 +8153,7 @@ code = '''
     lfsr_rbyd_t backup_rbyd = rbyd;
     uint8_t *backup_block = malloc(rbyd.eoff);
     lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-            rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+            rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
     // test all permutations of a given size
     size_t perm_count = TEST_FACTORIAL(N);
@@ -8176,9 +8176,9 @@ code = '''
 
         // restore backup
         rbyd = backup_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
         lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
         // delete each rid in permutation order
@@ -8198,7 +8198,7 @@ code = '''
         }
 
         // check that all tags are now removed
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 0);
         lfsr_rbyd_get(&lfs, &rbyd,
                 0, LFSR_TAG_REG, buffer, 4)
@@ -8214,7 +8214,7 @@ code = '''
         }
         assert(rbyd.weight == 1);
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == 1);
         lfsr_rbyd_get(&lfs, &rbyd,
                 0, LFSR_TAG_REG, buffer, 6)
@@ -8271,7 +8271,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -8308,7 +8308,7 @@ code = '''
 
     // set up rbyd block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     prng = SEED;
     count = 0;
@@ -8377,7 +8377,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -8391,7 +8391,7 @@ code = '''
 
     // make id0 with weight w1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -8402,7 +8402,7 @@ code = '''
     assert(weight_ == 1);
     assert(lfsr_data_size(&data_) == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8427,7 +8427,7 @@ code = '''
     assert(weight_ == 2);
     assert(lfsr_data_size(&data_) == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8464,7 +8464,7 @@ code = '''
     assert(weight_ == 3);
     assert(lfsr_data_size(&data_) == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8513,7 +8513,7 @@ code = '''
     assert(weight_ == 4);
     assert(lfsr_data_size(&data_) == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8574,7 +8574,7 @@ code = '''
     assert(weight_ == 5);
     assert(lfsr_data_size(&data_) == 4);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8614,7 +8614,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -8627,7 +8627,7 @@ code = '''
     lfsr_data_t data_;
 
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             // make id0 with weight w1
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
@@ -8674,7 +8674,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_REG);
@@ -8723,7 +8723,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -8765,7 +8765,7 @@ code = '''
 
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -8780,7 +8780,7 @@ code = '''
                         BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N*W);
         for (unsigned j = 0; j < N; j++) {
             lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG,
@@ -8810,7 +8810,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -8852,7 +8852,7 @@ code = '''
 
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -8867,7 +8867,7 @@ code = '''
                         BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N*W);
         // try traversing all tags
         tag_ = 0;
@@ -8896,7 +8896,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -8910,7 +8910,7 @@ code = '''
 
     // make id0 with weight w1
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)),
             LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)),
@@ -8942,7 +8942,7 @@ code = '''
     assert(weight_ == 0);
     assert(lfsr_data_size(&data_) == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9018,7 +9018,7 @@ code = '''
     assert(weight_ == 0);
     assert(lfsr_data_size(&data_) == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9130,7 +9130,7 @@ code = '''
     assert(weight_ == 0);
     assert(lfsr_data_size(&data_) == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9278,7 +9278,7 @@ code = '''
     assert(weight_ == 0);
     assert(lfsr_data_size(&data_) == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9462,7 +9462,7 @@ code = '''
     assert(weight_ == 0);
     assert(lfsr_data_size(&data_) == 2);
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9568,7 +9568,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -9581,7 +9581,7 @@ code = '''
     lfsr_data_t data_;
 
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
             LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)),
             // make id0 with weight w1
@@ -9709,7 +9709,7 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1,
             &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, &weight_, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(3));
@@ -9824,7 +9824,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -9866,7 +9866,7 @@ code = '''
 
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                 LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)))) => 0;
 
@@ -9887,7 +9887,7 @@ code = '''
                         BUF(names[perm[j] % 6], 2)))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N*W);
         lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
                 &rid_, &tag_, &weight_, &data_) => 0;
@@ -9935,7 +9935,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -9977,7 +9977,7 @@ code = '''
 
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                 LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)))) => 0;
 
@@ -9998,7 +9998,7 @@ code = '''
                         BUF(names[perm[j] % 6], 2)))) => 0;
         }
 
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N*W);
         // try traversing all tags
         tag_ = 0;
@@ -10056,7 +10056,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -10098,7 +10098,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -10118,7 +10118,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try growing each rid
         for (unsigned j = 0; j < N; j++) {
@@ -10126,16 +10126,16 @@ code = '''
             printf("--- growing: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(j*W+W-1, RM, +D, NULL()))) => 0;
             assert(rbyd.weight == N*W+D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W+D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10183,7 +10183,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -10225,7 +10225,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -10245,7 +10245,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try growing each rid
         for (unsigned j = 0; j < N; j++) {
@@ -10253,9 +10253,9 @@ code = '''
             printf("--- growing: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -10263,7 +10263,7 @@ code = '''
                         BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W+D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W+D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10319,7 +10319,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -10361,7 +10361,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -10381,7 +10381,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try growing each rid
         for (unsigned j = 0; j < N; j++) {
@@ -10389,9 +10389,9 @@ code = '''
             printf("--- growing: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -10399,7 +10399,7 @@ code = '''
                         BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W+D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W+D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10467,7 +10467,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -10509,7 +10509,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -10529,7 +10529,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try shrinking each rid
         for (unsigned j = 0; j < N; j++) {
@@ -10537,16 +10537,16 @@ code = '''
             printf("--- shrinking: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(j*W+W-1, GROW, -D, NULL()))) => 0;
             assert(rbyd.weight == N*W-D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W-D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10594,7 +10594,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -10636,7 +10636,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -10656,7 +10656,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try shrinking each rid
         for (unsigned j = 0; j < N; j++) {
@@ -10664,9 +10664,9 @@ code = '''
             printf("--- shrinking: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -10674,7 +10674,7 @@ code = '''
                         BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W-D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W-D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10730,7 +10730,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -10772,7 +10772,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -10792,7 +10792,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try shrinking each rid
         for (unsigned j = 0; j < N; j++) {
@@ -10800,9 +10800,9 @@ code = '''
             printf("--- shrinking: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -10810,7 +10810,7 @@ code = '''
                         BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W-D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W-D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10877,7 +10877,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -10919,7 +10919,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -10939,7 +10939,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try deleting each rid
         for (unsigned j = 0; j < N; j++) {
@@ -10947,16 +10947,16 @@ code = '''
             printf("--- deleting: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(j*W+W-1, RM, -W, NULL()))) => 0;
             assert(rbyd.weight == (N-1)*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == (N-1)*W);
             for (unsigned k = 0; k < N-1; k++) {
                 if (k >= j) {
@@ -10988,7 +10988,7 @@ code = '''
                     LFSR_ATTR(j*W, REG, +W, BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -11031,7 +11031,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -11073,7 +11073,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -11093,7 +11093,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try appending an attr to each rid, this should not affect
         // weights at all!
@@ -11102,9 +11102,9 @@ code = '''
             printf("--- appending: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
@@ -11112,7 +11112,7 @@ code = '''
                         BUF(names[j % 6], 2)))) => 0;
             assert(rbyd.weight == N*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W);
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -11142,7 +11142,7 @@ code = '''
                     LFSR_ATTR(j*W+W-1, RM(UATTR(1)), 0, NULL()))) => 0;
             assert(rbyd.weight == N*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W);
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -11168,7 +11168,7 @@ code = '''
                         BUF(names[j % 6], 2)))) => 0;
             assert(rbyd.weight == N*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             assert(rbyd.weight == N*W);
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -11210,7 +11210,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -11255,7 +11255,7 @@ code = '''
 
     // set up rbyd block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     prng = SEED;
     count = 0;
@@ -11361,7 +11361,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -11412,7 +11412,7 @@ code = '''
 
     // set up rbyd block
     rbyd = init_rbyd;
-    lfs_bd_erase(&lfs, rbyd.block) => 0;
+    lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     prng = SEED;
     count = 0;
@@ -11556,7 +11556,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -11593,7 +11593,7 @@ code = '''
 
         // build the attribute list for the current permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -11612,7 +11612,7 @@ code = '''
         assert(rbyd.weight == N);
 
         // test that we can lookup each attr with a wide lookup
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
         for (unsigned j = 0; j < N; j++) {
@@ -11643,7 +11643,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -11680,7 +11680,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -11702,7 +11702,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try removing each tag
         for (unsigned j = 0; j < N; j++) {
@@ -11710,9 +11710,9 @@ code = '''
             printf("--- remove: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             // remove with a wide tag
@@ -11720,7 +11720,7 @@ code = '''
                     LFSR_ATTR(j, RM(WIDE(UATTR)), 0, NULL()))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t rid_ = -1;
             lfs_size_t weight_;
@@ -11780,7 +11780,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -11817,7 +11817,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -11839,7 +11839,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try replacing each tag
         for (unsigned j = 0; j < N; j++) {
@@ -11847,9 +11847,9 @@ code = '''
             printf("--- replace: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             // replace with bitwise inverse
@@ -11858,7 +11858,7 @@ code = '''
                         BUF(names[j % 6], 3)))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t rid_ = -1;
             lfs_size_t weight_;
@@ -11919,7 +11919,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -11956,7 +11956,7 @@ code = '''
 
         // build the attribute list for the current permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -11977,7 +11977,7 @@ code = '''
         assert(rbyd.weight == N);
 
         // test that we can lookup each attr with a wide lookup
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
         for (unsigned j = 0; j < N; j++) {
@@ -12008,7 +12008,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -12045,7 +12045,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -12069,7 +12069,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try removing each tag
         for (unsigned j = 0; j < N; j++) {
@@ -12077,9 +12077,9 @@ code = '''
             printf("--- remove: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             // remove with a wide tag
@@ -12087,7 +12087,7 @@ code = '''
                     LFSR_ATTR(j, RM(WIDE(UATTR)), 0, NULL()))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t rid_ = -1;
             lfs_size_t weight_;
@@ -12154,7 +12154,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -12191,7 +12191,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -12215,7 +12215,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try replacing each tag
         for (unsigned j = 0; j < N; j++) {
@@ -12223,9 +12223,9 @@ code = '''
             printf("--- replace: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             // replace with bitwise inverse
@@ -12234,7 +12234,7 @@ code = '''
                         BUF(names[j % 6], 3)))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t rid_ = -1;
             lfs_size_t weight_;
@@ -12302,7 +12302,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -12339,7 +12339,7 @@ code = '''
 
         // build the attribute list for the current permutation
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -12357,7 +12357,7 @@ code = '''
         assert(rbyd.weight == N);
 
         // test that we can lookup each attr with a wide lookup
-        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0;
+        lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
         for (unsigned j = 0; j < N; j++) {
@@ -12388,7 +12388,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -12425,7 +12425,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -12446,7 +12446,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try removing each tag
         for (unsigned j = 0; j < N; j++) {
@@ -12454,9 +12454,9 @@ code = '''
             printf("--- remove: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             // remove with a wide tag
@@ -12464,7 +12464,7 @@ code = '''
                     LFSR_ATTR(j, RM(WIDE(UATTR)), 0, NULL()))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t rid_ = -1;
             lfs_size_t weight_;
@@ -12527,7 +12527,7 @@ code = '''
     lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
-        .block = 0,
+        .blocks[0] = 0,
         .eoff = 0,
         .cksum = 0,
         .trunk = 0,
@@ -12564,7 +12564,7 @@ code = '''
 
         // create given permutation with multiple commits
         rbyd = init_rbyd;
-        lfs_bd_erase(&lfs, rbyd.block) => 0;
+        lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
             uint16_t rid = perm[j];
@@ -12585,7 +12585,7 @@ code = '''
         lfsr_rbyd_t backup_rbyd = rbyd;
         uint8_t *backup_block = malloc(rbyd.eoff);
         lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff,
-                rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
 
         // try replacing each tag
         for (unsigned j = 0; j < N; j++) {
@@ -12593,9 +12593,9 @@ code = '''
             printf("--- replace: %d ---\n", j);
 
             rbyd = backup_rbyd;
-            lfs_bd_erase(&lfs, rbyd.block) => 0;
+            lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0;
             lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
-                    rbyd.block, 0, backup_block, rbyd.eoff) => 0;
+                    rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0;
             lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
 
             // replace with bitwise inverse
@@ -12604,7 +12604,7 @@ code = '''
                         BUF(names[j % 6], 6)))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t rid_ = -1;
             lfs_size_t weight_;