diff --git a/lfs3.c b/lfs3.c
index 6bd688ae..5e804716 100644
--- a/lfs3.c
+++ b/lfs3.c
@@ -2431,12 +2431,12 @@ static void lfs3_bptr_init(lfs3_bptr_t *bptr,
         lfs3_data_t data, lfs3_size_t cksize, uint32_t cksum) {
     // make sure the bptr flag is set
     LFS3_ASSERT(lfs3_data_ondisk(data));
-    bptr->data.size = data.size | LFS3_DATA_ONDISK | LFS3_BPTR_ISBPTR;
-    bptr->data.u.disk.block = data.u.disk.block;
-    bptr->data.u.disk.off = data.u.disk.off;
+    bptr->d.size = data.size | LFS3_DATA_ONDISK | LFS3_BPTR_ISBPTR;
+    bptr->d.u.disk.block = data.u.disk.block;
+    bptr->d.u.disk.off = data.u.disk.off;
     #ifdef LFS3_CKDATACKSUMREADS
-    bptr->data.u.disk.cksize = cksize;
-    bptr->data.u.disk.cksum = cksum;
+    bptr->d.u.disk.cksize = cksize;
+    bptr->d.u.disk.cksum = cksum;
     #else
     bptr->cksize = cksize;
     bptr->cksum = cksum;
@@ -2445,7 +2445,7 @@ static void lfs3_bptr_init(lfs3_bptr_t *bptr,
 #endif
 
 static inline void lfs3_bptr_discard(lfs3_bptr_t *bptr) {
-    bptr->data = LFS3_DATA_NULL();
+    bptr->d = LFS3_DATA_NULL();
     #if !defined(LFS3_2BONLY) && !defined(LFS3_CKDATACKSUMREADS)
     bptr->cksize = 0;
     bptr->cksum = 0;
@@ -2455,7 +2455,7 @@ static inline void lfs3_bptr_discard(lfs3_bptr_t *bptr) {
 #if !defined(LFS3_RDONLY) && !defined(LFS3_2BONLY)
 static inline void lfs3_bptr_claim(lfs3_bptr_t *bptr) {
     #ifdef LFS3_CKDATACKSUMREADS
-    bptr->data.u.disk.cksize &= ~LFS3_BPTR_ISERASED;
+    bptr->d.u.disk.cksize &= ~LFS3_BPTR_ISERASED;
     #else
     bptr->cksize &= ~LFS3_BPTR_ISERASED;
     #endif
@@ -2463,19 +2463,19 @@ static inline void lfs3_bptr_claim(lfs3_bptr_t *bptr) {
 #endif
 
 static inline bool lfs3_bptr_isbptr(const lfs3_bptr_t *bptr) {
-    return bptr->data.size & LFS3_BPTR_ISBPTR;
+    return bptr->d.size & LFS3_BPTR_ISBPTR;
 }
 
 static inline lfs3_block_t lfs3_bptr_block(const lfs3_bptr_t *bptr) {
-    return bptr->data.u.disk.block;
+    return bptr->d.u.disk.block;
 }
 
 static inline lfs3_size_t lfs3_bptr_off(const lfs3_bptr_t *bptr) {
-    return bptr->data.u.disk.off;
+    return bptr->d.u.disk.off;
 }
 
 static inline lfs3_size_t lfs3_bptr_size(const lfs3_bptr_t *bptr) {
-    return bptr->data.size & ~LFS3_BPTR_ONDISK & ~LFS3_BPTR_ISBPTR;
+    return bptr->d.size & ~LFS3_BPTR_ONDISK & ~LFS3_BPTR_ISBPTR;
 }
 
 // checked reads adds ck info to lfs3_data_t that we don't want to
@@ -2484,7 +2484,7 @@ static inline lfs3_size_t lfs3_bptr_size(const lfs3_bptr_t *bptr) {
 #if !defined(LFS3_RDONLY) && !defined(LFS3_2BONLY)
 static inline bool lfs3_bptr_iserased(const lfs3_bptr_t *bptr) {
     #ifdef LFS3_CKDATACKSUMREADS
-    return bptr->data.u.disk.cksize & LFS3_BPTR_ISERASED;
+    return bptr->d.u.disk.cksize & LFS3_BPTR_ISERASED;
     #else
     return bptr->cksize & LFS3_BPTR_ISERASED;
     #endif
@@ -2495,8 +2495,8 @@ static inline bool lfs3_bptr_iserased(const lfs3_bptr_t *bptr) {
 static inline lfs3_size_t lfs3_bptr_cksize(const lfs3_bptr_t *bptr) {
     #ifdef LFS3_CKDATACKSUMREADS
     return LFS3_IFDEF_RDONLY(
-            bptr->data.u.disk.cksize,
-            bptr->data.u.disk.cksize & ~LFS3_BPTR_ISERASED);
+            bptr->d.u.disk.cksize,
+            bptr->d.u.disk.cksize & ~LFS3_BPTR_ISERASED);
     #else
     return LFS3_IFDEF_RDONLY(
             bptr->cksize,
@@ -2508,7 +2508,7 @@ static inline lfs3_size_t lfs3_bptr_cksize(const lfs3_bptr_t *bptr) {
 #ifndef LFS3_2BONLY
 static inline uint32_t lfs3_bptr_cksum(const lfs3_bptr_t *bptr) {
     #ifdef LFS3_CKDATACKSUMREADS
-    return bptr->data.u.disk.cksum;
+    return bptr->d.u.disk.cksum;
     #else
     return bptr->cksum;
     #endif
@@ -2520,7 +2520,7 @@ static inline uint32_t lfs3_bptr_cksum(const lfs3_bptr_t *bptr) {
 static lfs3_data_t lfs3_data_frombptr(const lfs3_bptr_t *bptr,
         uint8_t buffer[static LFS3_BPTR_DSIZE]) {
     // size should not exceed 28-bits
-    LFS3_ASSERT(lfs3_data_size(bptr->data) <= 0x0fffffff);
+    LFS3_ASSERT(lfs3_data_size(bptr->d) <= 0x0fffffff);
     // block should not exceed 31-bits
     LFS3_ASSERT(lfs3_bptr_block(bptr) <= 0x7fffffff);
     // off should not exceed 28-bits
@@ -2530,7 +2530,7 @@ static lfs3_data_t lfs3_data_frombptr(const lfs3_bptr_t *bptr,
     lfs3_ssize_t d = 0;
 
     // write the block, offset, size
-    lfs3_ssize_t d_ = lfs3_toleb128(lfs3_data_size(bptr->data), &buffer[d], 4);
+    lfs3_ssize_t d_ = lfs3_toleb128(lfs3_data_size(bptr->d), &buffer[d], 4);
     if (d_ < 0) {
         LFS3_UNREACHABLE();
     }
@@ -2566,17 +2566,17 @@ static lfs3_data_t lfs3_data_frombptr(const lfs3_bptr_t *bptr,
 static int lfs3_data_readbptr(lfs3_t *lfs3, lfs3_data_t *data,
         lfs3_bptr_t *bptr) {
     // read the block, offset, size
-    int err = lfs3_data_readlleb128(lfs3, data, &bptr->data.size);
+    int err = lfs3_data_readlleb128(lfs3, data, &bptr->d.size);
     if (err) {
         return err;
     }
 
-    err = lfs3_data_readleb128(lfs3, data, &bptr->data.u.disk.block);
+    err = lfs3_data_readleb128(lfs3, data, &bptr->d.u.disk.block);
     if (err) {
         return err;
     }
 
-    err = lfs3_data_readlleb128(lfs3, data, &bptr->data.u.disk.off);
+    err = lfs3_data_readlleb128(lfs3, data, &bptr->d.u.disk.off);
     if (err) {
         return err;
     }
@@ -2584,7 +2584,7 @@ static int lfs3_data_readbptr(lfs3_t *lfs3, lfs3_data_t *data,
     // read the cksize, cksum
     err = lfs3_data_readlleb128(lfs3, data,
             LFS3_IFDEF_CKDATACKSUMREADS(
-                &bptr->data.u.disk.cksize,
+                &bptr->d.u.disk.cksize,
                 &bptr->cksize));
     if (err) {
         return err;
@@ -2592,14 +2592,14 @@ static int lfs3_data_readbptr(lfs3_t *lfs3, lfs3_data_t *data,
 
     err = lfs3_data_readle32(lfs3, data,
             LFS3_IFDEF_CKDATACKSUMREADS(
-                &bptr->data.u.disk.cksum,
+                &bptr->d.u.disk.cksum,
                 &bptr->cksum));
     if (err) {
         return err;
     }
 
     // mark as on-disk + cksum
-    bptr->data.size |= LFS3_DATA_ONDISK | LFS3_DATA_ISBPTR;
+    bptr->d.size |= LFS3_DATA_ONDISK | LFS3_DATA_ISBPTR;
     return 0;
 }
 #endif
@@ -2615,7 +2615,7 @@ static int lfs3_bptr_fetch(lfs3_t *lfs3, lfs3_bptr_t *bptr,
         lfs3_tag_t tag, lfs3_bid_t weight, lfs3_data_t data) {
     // fragment? (inlined data)
     if (tag == LFS3_TAG_DATA) {
-        bptr->data = data;
+        bptr->d = data;
 
     // bptr?
     } else if (LFS3_IFDEF_2BONLY(false, tag == LFS3_TAG_BLOCK)) {
@@ -2633,7 +2633,7 @@ static int lfs3_bptr_fetch(lfs3_t *lfs3, lfs3_bptr_t *bptr,
 
     // limit bptrs to btree weights, this may be useful for
     // compression in the future
-    bptr->data = LFS3_DATA_TRUNCATE(bptr->data, weight);
+    bptr->d = LFS3_DATA_TRUNCATE(bptr->d, weight);
 
     // checking fetches?
     #ifdef LFS3_CKFETCHES
@@ -6458,7 +6458,7 @@ static int lfs3_data_readshrub(lfs3_t *lfs3,
         const lfs3_mdir_t *mdir, lfs3_data_t *data,
         lfs3_shrub_t *shrub) {
     // copy the mdir block
-    shrub->blocks[0] = mdir->rbyd.blocks[0];
+    shrub->blocks[0] = mdir->r.blocks[0];
     // force estimate recalculation if we write to this shrub
     #ifndef LFS3_RDONLY
     shrub->eoff = -1;
@@ -6833,7 +6833,7 @@ static int lfs3_bshrub_commitroot_(lfs3_t *lfs3, lfs3_bshrub_t *bshrub,
     if (err) {
         return err;
     }
-    LFS3_ASSERT(bshrub->shrub.blocks[0] == bshrub->o.mdir.rbyd.blocks[0]);
+    LFS3_ASSERT(bshrub->shrub.blocks[0] == bshrub->o.mdir.r.blocks[0]);
 
     // update _all_ shrubs with the new estimate
     for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) {
@@ -6919,7 +6919,7 @@ static int lfs3_bshrub_commit(lfs3_t *lfs3, lfs3_bshrub_t *bshrub,
     if (lfs3_bshrub_isbshrub(bshrub)) {
         LFS3_DEBUG("Committed bshrub "
                     "0x{%"PRIx32",%"PRIx32"}.%"PRIx32" w%"PRId32,
-                bshrub->o.mdir.rbyd.blocks[0], bshrub->o.mdir.rbyd.blocks[1],
+                bshrub->o.mdir.r.blocks[0], bshrub->o.mdir.r.blocks[1],
                 lfs3_shrub_trunk(&bshrub->shrub),
                 bshrub->shrub.weight);
     } else {
@@ -7609,7 +7609,7 @@ static int lfs3_fs_consumegdelta(lfs3_t *lfs3, const lfs3_mdir_t *mdir) {
 
     // consume any grm deltas
     lfs3_data_t data;
-    int err = lfs3_rbyd_lookup(lfs3, &mdir->rbyd, -1, LFS3_TAG_GRMDELTA,
+    int err = lfs3_rbyd_lookup(lfs3, &mdir->r, -1, LFS3_TAG_GRMDELTA,
             NULL, &data);
     if (err && err != LFS3_ERR_NOENT) {
         return err;
@@ -7748,21 +7748,21 @@ static inline uint32_t lfs3_rev_inc(lfs3_t *lfs3, uint32_t rev) {
 // mdir convenience functions
 #ifndef LFS3_RDONLY
 static inline void lfs3_mdir_claim(lfs3_mdir_t *mdir) {
-    lfs3_rbyd_claim(&mdir->rbyd);
+    lfs3_rbyd_claim(&mdir->r);
 }
 #endif
 
 static inline int lfs3_mdir_cmp(const lfs3_mdir_t *a, const lfs3_mdir_t *b) {
-    return lfs3_mptr_cmp(a->rbyd.blocks, b->rbyd.blocks);
+    return lfs3_mptr_cmp(a->r.blocks, b->r.blocks);
 }
 
 static inline bool lfs3_mdir_ismrootanchor(const lfs3_mdir_t *mdir) {
-    return lfs3_mptr_ismrootanchor(mdir->rbyd.blocks);
+    return lfs3_mptr_ismrootanchor(mdir->r.blocks);
 }
 
 static inline void lfs3_mdir_sync(lfs3_mdir_t *a, const lfs3_mdir_t *b) {
     // copy over everything but the mid
-    a->rbyd = b->rbyd;
+    a->r = b->r;
     a->gcksumdelta = b->gcksumdelta;
 }
 
@@ -7795,7 +7795,7 @@ static int lfs3_mdir_fetch(lfs3_t *lfs3, lfs3_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 = lfs3_rbyd_fetch_(lfs3,
-                &mdir->rbyd, &mdir->gcksumdelta,
+                &mdir->r, &mdir->gcksumdelta,
                 blocks[0], 0);
         if (err && err != LFS3_ERR_CORRUPT) {
             return err;
@@ -7804,16 +7804,16 @@ static int lfs3_mdir_fetch(lfs3_t *lfs3, lfs3_mdir_t *mdir,
         if (err != LFS3_ERR_CORRUPT) {
             mdir->mid = mid;
             // keep track of other block for compactions
-            mdir->rbyd.blocks[1] = blocks[1];
+            mdir->r.blocks[1] = blocks[1];
             #ifdef LFS3_DBGMDIRFETCHES
             LFS3_DEBUG("Fetched mdir %"PRId32" "
                         "0x{%"PRIx32",%"PRIx32"}.%"PRIx32" w%"PRId32", "
                         "cksum %"PRIx32,
                     lfs3_dbgmbid(lfs3, mdir->mid),
-                    mdir->rbyd.blocks[0], mdir->rbyd.blocks[1],
-                    lfs3_rbyd_trunk(&mdir->rbyd),
-                    mdir->rbyd.weight,
-                    mdir->rbyd.cksum);
+                    mdir->r.blocks[0], mdir->r.blocks[1],
+                    lfs3_rbyd_trunk(&mdir->r),
+                    mdir->r.weight,
+                    mdir->r.cksum);
             #endif
             return 0;
         }
@@ -7831,12 +7831,12 @@ static int lfs3_data_fetchmdir(lfs3_t *lfs3,
         lfs3_mdir_t *mdir) {
     // decode mptr and fetch
     int err = lfs3_data_readmptr(lfs3, data,
-            mdir->rbyd.blocks);
+            mdir->r.blocks);
     if (err) {
         return err;
     }
 
-    return lfs3_mdir_fetch(lfs3, mdir, mid, mdir->rbyd.blocks);
+    return lfs3_mdir_fetch(lfs3, mdir, mid, mdir->r.blocks);
 }
 
 static lfs3_tag_t lfs3_mdir_nametag(const lfs3_t *lfs3, const lfs3_mdir_t *mdir,
@@ -7875,7 +7875,7 @@ static int lfs3_mdir_lookupnext(lfs3_t *lfs3, const lfs3_mdir_t *mdir,
         lfs3_tag_t *tag_, lfs3_data_t *data_) {
     lfs3_srid_t rid__;
     lfs3_tag_t tag__;
-    int err = lfs3_rbyd_lookupnext(lfs3, &mdir->rbyd,
+    int err = lfs3_rbyd_lookupnext(lfs3, &mdir->r,
             lfs3_mrid(lfs3, mdir->mid), tag,
             &rid__, &tag__, NULL, data_);
     if (err) {
@@ -7958,7 +7958,7 @@ static int lfs3_mtree_lookup(lfs3_t *lfs3, lfs3_smid_t mid,
         lfs3_bid_t weight;
         lfs3_data_t data;
         int err = lfs3_btree_lookupleaf(lfs3, &lfs3->mtree, mid,
-                &bid, &mdir_->rbyd, &rid, &tag, &weight, &data);
+                &bid, &mdir_->r, &rid, &tag, &weight, &data);
         if (err) {
             LFS3_ASSERT(err != LFS3_ERR_NOENT);
             return err;
@@ -7970,7 +7970,7 @@ static int lfs3_mtree_lookup(lfs3_t *lfs3, lfs3_smid_t mid,
 
         // if we found an mname, lookup the mdir
         if (tag == LFS3_TAG_MNAME) {
-            err = lfs3_rbyd_lookup(lfs3, &mdir_->rbyd, rid, LFS3_TAG_MDIR,
+            err = lfs3_rbyd_lookup(lfs3, &mdir_->r, rid, LFS3_TAG_MDIR,
                     NULL, &data);
             if (err) {
                 LFS3_ASSERT(err != LFS3_ERR_NOENT);
@@ -8028,7 +8028,7 @@ static int lfs3_mdir_alloc__(lfs3_t *lfs3, lfs3_mdir_t *mdir,
         if (block < 0) {
             return block;
         }
-        mdir->rbyd.blocks[1] = block;
+        mdir->r.blocks[1] = block;
     }
 
     // read the new revision count
@@ -8036,7 +8036,7 @@ static int lfs3_mdir_alloc__(lfs3_t *lfs3, lfs3_mdir_t *mdir,
     // we use whatever is on-disk to avoid needing to rewrite the
     // redund block
     uint32_t rev;
-    int err = lfs3_bd_read(lfs3, mdir->rbyd.blocks[1], 0, 0,
+    int err = lfs3_bd_read(lfs3, mdir->r.blocks[1], 0, 0,
             &rev, sizeof(uint32_t));
     if (err && err != LFS3_ERR_CORRUPT) {
         return err;
@@ -8052,14 +8052,14 @@ relocate:;
     if (block < 0) {
         return block;
     }
-    mdir->rbyd.blocks[0] = block;
-    mdir->rbyd.weight = 0;
-    mdir->rbyd.trunk = 0;
-    mdir->rbyd.eoff = 0;
-    mdir->rbyd.cksum = 0;
+    mdir->r.blocks[0] = block;
+    mdir->r.weight = 0;
+    mdir->r.trunk = 0;
+    mdir->r.eoff = 0;
+    mdir->r.cksum = 0;
 
     // write our revision count
-    err = lfs3_rbyd_appendrev(lfs3, &mdir->rbyd, rev);
+    err = lfs3_rbyd_appendrev(lfs3, &mdir->r, rev);
     if (err) {
         // bad prog? try another block
         if (err == LFS3_ERR_CORRUPT) {
@@ -8082,7 +8082,7 @@ static int lfs3_mdir_swap__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
 
     // first thing we need to do is read our current revision count
     uint32_t rev;
-    int err = lfs3_bd_read(lfs3, mdir->rbyd.blocks[0], 0, 0,
+    int err = lfs3_bd_read(lfs3, mdir->r.blocks[0], 0, 0,
             &rev, sizeof(uint32_t));
     if (err && err != LFS3_ERR_CORRUPT) {
         return err;
@@ -8098,21 +8098,21 @@ static int lfs3_mdir_swap__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
     }
 
     // swap our blocks
-    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;
+    mdir_->r.blocks[0] = mdir->r.blocks[1];
+    mdir_->r.blocks[1] = mdir->r.blocks[0];
+    mdir_->r.weight = 0;
+    mdir_->r.trunk = 0;
+    mdir_->r.eoff = 0;
+    mdir_->r.cksum = 0;
 
     // erase, preparing for compact
-    err = lfs3_bd_erase(lfs3, mdir_->rbyd.blocks[0]);
+    err = lfs3_bd_erase(lfs3, mdir_->r.blocks[0]);
     if (err) {
         return err;
     }
 
     // increment our revision count and write it to our rbyd
-    err = lfs3_rbyd_appendrev(lfs3, &mdir_->rbyd, rev);
+    err = lfs3_rbyd_appendrev(lfs3, &mdir_->r, rev);
     if (err) {
         return err;
     }
@@ -8164,14 +8164,14 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
                 // reset shrub if it doesn't live in our block, this happens
                 // when converting from a btree
                 if (!lfs3_bshrub_isbshrub(bshrub_)) {
-                    bshrub_->shrub_.blocks[0] = mdir_->rbyd.blocks[0];
+                    bshrub_->shrub_.blocks[0] = mdir_->r.blocks[0];
                     bshrub_->shrub_.trunk = LFS3_RBYD_ISSHRUB | 0;
                     bshrub_->shrub_.weight = 0;
                 }
 
                 // commit to shrub
                 int err = lfs3_shrub_commit(lfs3,
-                        &mdir_->rbyd, &bshrub_->shrub_,
+                        &mdir_->r, &bshrub_->shrub_,
                         rid_, rattrs_, rattr_count_);
                 if (err) {
                     return err;
@@ -8212,14 +8212,14 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
                         }
 
                         // compact our shrub
-                        err = lfs3_shrub_compact(lfs3, &mdir_->rbyd, &shrub,
+                        err = lfs3_shrub_compact(lfs3, &mdir_->r, &shrub,
                                 &shrub);
                         if (err) {
                             return err;
                         }
 
                         // write our new shrub tag
-                        err = lfs3_rbyd_appendrattr(lfs3, &mdir_->rbyd,
+                        err = lfs3_rbyd_appendrattr(lfs3, &mdir_->r,
                                 rid - lfs3_smax(start_rid, 0),
                                 LFS3_RATTR_SHRUB(LFS3_TAG_BSHRUB, 0, &shrub));
                         if (err) {
@@ -8228,7 +8228,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
 
                     // append the rattr
                     } else {
-                        err = lfs3_rbyd_appendrattr(lfs3, &mdir_->rbyd,
+                        err = lfs3_rbyd_appendrattr(lfs3, &mdir_->r,
                                 rid - lfs3_smax(start_rid, 0),
                                 LFS3_RATTR_DATA(tag, 0, &data));
                         if (err) {
@@ -8248,8 +8248,8 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
                             // only compact once, first compact should
                             // stage the new block
                             && ((lfs3_bshrub_t*)o)->shrub_.blocks[0]
-                                != mdir_->rbyd.blocks[0]) {
-                        int err = lfs3_shrub_compact(lfs3, &mdir_->rbyd,
+                                != mdir_->r.blocks[0]) {
+                        int err = lfs3_shrub_compact(lfs3, &mdir_->r,
                                 &((lfs3_bshrub_t*)o)->shrub_,
                                 &((lfs3_bshrub_t*)o)->shrub);
                         if (err) {
@@ -8291,7 +8291,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
                     }
 
                     // append the custom attr
-                    err = lfs3_rbyd_appendrattr(lfs3, &mdir_->rbyd,
+                    err = lfs3_rbyd_appendrattr(lfs3, &mdir_->r,
                             rid - lfs3_smax(start_rid, 0),
                             // removing or updating?
                             (lfs3_attr_isnoattr(&attrs_[j]))
@@ -8311,7 +8311,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
             } else {
                 LFS3_ASSERT(!lfs3_tag_isinternal(rattrs[i].tag));
 
-                int err = lfs3_rbyd_appendrattr(lfs3, &mdir_->rbyd,
+                int err = lfs3_rbyd_appendrattr(lfs3, &mdir_->r,
                         rid - lfs3_smax(start_rid, 0),
                         rattrs[i]);
                 if (err) {
@@ -8329,7 +8329,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
     // If we finish the commit it becomes immediately visible, but we really
     // need to atomically remove this mdir from the mtree. Leave the actual
     // remove up to upper layers.
-    if (mdir_->rbyd.weight == 0
+    if (mdir_->r.weight == 0
             // unless we are an mroot
             && !(mdir_->mid == -1
                 || lfs3_mdir_cmp(mdir_, &lfs3->mroot) == 0)) {
@@ -8340,7 +8340,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
 
     // append any gstate?
     if (start_rid <= -2) {
-        int err = lfs3_rbyd_appendgdelta(lfs3, &mdir_->rbyd);
+        int err = lfs3_rbyd_appendgdelta(lfs3, &mdir_->r);
         if (err) {
             return err;
         }
@@ -8350,7 +8350,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
     //
     // note this is before we calculate gcksumdelta, otherwise
     // everything would get all self-referential
-    uint32_t cksum = mdir_->rbyd.cksum;
+    uint32_t cksum = mdir_->r.cksum;
 
     // append gkcsumdelta?
     if (start_rid <= -2) {
@@ -8359,7 +8359,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
                 ^ lfs3_crc32c_cube(lfs3->gcksum ^ cksum)
                 ^ lfs3->gcksum_d;
 
-        int err = lfs3_rbyd_appendrattr_(lfs3, &mdir_->rbyd, LFS3_RATTR_LE32(
+        int err = lfs3_rbyd_appendrattr_(lfs3, &mdir_->r, LFS3_RATTR_LE32(
                 LFS3_TAG_GCKSUMDELTA, 0, mdir_->gcksumdelta));
         if (err) {
             return err;
@@ -8367,7 +8367,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
     }
 
     // finalize commit
-    int err = lfs3_rbyd_appendcksum_(lfs3, &mdir_->rbyd, cksum);
+    int err = lfs3_rbyd_appendcksum_(lfs3, &mdir_->r, cksum);
     if (err) {
         return err;
     }
@@ -8375,7 +8375,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_,
     // success?
 
     // xor our new cksum
-    lfs3->gcksum ^= mdir_->rbyd.cksum;
+    lfs3->gcksum ^= mdir_->r.cksum;
 
     return 0;
 }
@@ -8395,7 +8395,7 @@ static lfs3_ssize_t lfs3_mdir_estimate__(lfs3_t *lfs3, const lfs3_mdir_t *mdir,
     // calculate dsize by starting from the outside ids and working inwards,
     // this naturally gives us a split rid
     lfs3_srid_t a_rid = lfs3_smax(start_rid, -1);
-    lfs3_srid_t b_rid = lfs3_min(mdir->rbyd.weight, end_rid);
+    lfs3_srid_t b_rid = lfs3_min(mdir->r.weight, end_rid);
     lfs3_size_t a_dsize = 0;
     lfs3_size_t b_dsize = 0;
     lfs3_size_t mdir_dsize = 0;
@@ -8417,7 +8417,7 @@ static lfs3_ssize_t lfs3_mdir_estimate__(lfs3_t *lfs3, const lfs3_mdir_t *mdir,
         while (true) {
             lfs3_srid_t rid_;
             lfs3_data_t data;
-            int err = lfs3_rbyd_lookupnext(lfs3, &mdir->rbyd,
+            int err = lfs3_rbyd_lookupnext(lfs3, &mdir->r,
                     a_rid, tag+1,
                     &rid_, &tag, NULL, &data);
             if (err) {
@@ -8526,7 +8526,7 @@ static int lfs3_mdir_compact__(lfs3_t *lfs3,
     while (true) {
         lfs3_rid_t weight;
         lfs3_data_t data;
-        int err = lfs3_rbyd_lookupnext(lfs3, &mdir->rbyd,
+        int err = lfs3_rbyd_lookupnext(lfs3, &mdir->r,
                 rid, tag+1,
                 &rid, &tag, &weight, &data);
         if (err) {
@@ -8553,7 +8553,7 @@ static int lfs3_mdir_compact__(lfs3_t *lfs3,
             }
 
             // compact our shrub
-            err = lfs3_shrub_compact(lfs3, &mdir_->rbyd, &shrub,
+            err = lfs3_shrub_compact(lfs3, &mdir_->r, &shrub,
                     &shrub);
             if (err) {
                 LFS3_ASSERT(err != LFS3_ERR_RANGE);
@@ -8561,7 +8561,7 @@ static int lfs3_mdir_compact__(lfs3_t *lfs3,
             }
 
             // write the new shrub tag
-            err = lfs3_rbyd_appendcompactrattr(lfs3, &mdir_->rbyd,
+            err = lfs3_rbyd_appendcompactrattr(lfs3, &mdir_->r,
                     LFS3_RATTR_SHRUB(tag, weight, &shrub));
             if (err) {
                 LFS3_ASSERT(err != LFS3_ERR_RANGE);
@@ -8570,7 +8570,7 @@ static int lfs3_mdir_compact__(lfs3_t *lfs3,
 
         } else {
             // write the tag
-            err = lfs3_rbyd_appendcompactrattr(lfs3, &mdir_->rbyd,
+            err = lfs3_rbyd_appendcompactrattr(lfs3, &mdir_->r,
                     LFS3_RATTR_DATA(tag, weight, &data));
             if (err) {
                 LFS3_ASSERT(err != LFS3_ERR_RANGE);
@@ -8579,7 +8579,7 @@ static int lfs3_mdir_compact__(lfs3_t *lfs3,
         }
     }
 
-    int err = lfs3_rbyd_appendcompaction(lfs3, &mdir_->rbyd, 0);
+    int err = lfs3_rbyd_appendcompaction(lfs3, &mdir_->r, 0);
     if (err) {
         LFS3_ASSERT(err != LFS3_ERR_RANGE);
         return err;
@@ -8598,8 +8598,8 @@ static int lfs3_mdir_compact__(lfs3_t *lfs3,
                 // only compact once, first compact should
                 // stage the new block
                 && ((lfs3_bshrub_t*)o)->shrub_.blocks[0]
-                    != mdir_->rbyd.blocks[0]) {
-            int err = lfs3_shrub_compact(lfs3, &mdir_->rbyd,
+                    != mdir_->r.blocks[0]) {
+            int err = lfs3_shrub_compact(lfs3, &mdir_->r,
                     &((lfs3_bshrub_t*)o)->shrub_,
                     &((lfs3_bshrub_t*)o)->shrub);
             if (err) {
@@ -8679,8 +8679,8 @@ compact:;
         LFS3_DEBUG("Compacting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} "
                     "-> 0x{%"PRIx32",%"PRIx32"}",
                 lfs3_dbgmbid(lfs3, mdir->mid),
-                mdir->rbyd.blocks[0], mdir->rbyd.blocks[1],
-                mdir_->rbyd.blocks[0], mdir_->rbyd.blocks[1]);
+                mdir->r.blocks[0], mdir->r.blocks[1],
+                mdir_->r.blocks[0], mdir_->r.blocks[1]);
         #endif
 
         // don't copy over gcksum if relocating
@@ -8737,7 +8737,7 @@ compact:;
         if (err == LFS3_ERR_NOSPC) {
             LFS3_WARN("Overrecycling mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}",
                     lfs3_dbgmbid(lfs3, mdir->mid),
-                    mdir->rbyd.blocks[0], mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0], mdir->r.blocks[1]);
             relocated = false;
             overrecyclable = false;
 
@@ -8746,8 +8746,8 @@ compact:;
                 // bad prog? can't do much here, mdir stuck
                 if (err == LFS3_ERR_CORRUPT) {
                     LFS3_ERROR("Stuck mdir 0x{%"PRIx32",%"PRIx32"}",
-                            mdir->rbyd.blocks[0],
-                            mdir->rbyd.blocks[1]);
+                            mdir->r.blocks[0],
+                            mdir->r.blocks[1]);
                     return LFS3_ERR_NOSPC;
                 }
                 return err;
@@ -8819,10 +8819,10 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
     LFS3_ASSERT(mdir->mid == -1
             // note inlined mdirs are mroots with mid != -1
             || lfs3_mdir_cmp(mdir, &lfs3->mroot) == 0
-            || mdir->rbyd.weight > 0);
+            || mdir->r.weight > 0);
     // rid in-bounds?
     LFS3_ASSERT(lfs3_mrid(lfs3, mdir->mid)
-            <= (lfs3_srid_t)mdir->rbyd.weight);
+            <= (lfs3_srid_t)mdir->r.weight);
     // lfs3->mroot must have mid=-1
     LFS3_ASSERT(lfs3->mroot.mid == -1);
 
@@ -8857,7 +8857,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
     lfs3_fs_flushgdelta(lfs3);
 
     // xor our old cksum
-    lfs3->gcksum ^= mdir->rbyd.cksum;
+    lfs3->gcksum ^= mdir->r.cksum;
 
     // stage any bshrubs
     for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) {
@@ -8866,7 +8866,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
             // horribly wrong
             LFS3_ASSERT(!lfs3_bshrub_isbshrub((lfs3_bshrub_t*)o)
                     || ((lfs3_bshrub_t*)o)->shrub.blocks[0]
-                        == o->mdir.rbyd.blocks[0]);
+                        == o->mdir.r.blocks[0]);
             ((lfs3_bshrub_t*)o)->shrub_ = ((lfs3_bshrub_t*)o)->shrub;
         }
     }
@@ -8953,7 +8953,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
             }
             // empty? set weight to zero
             if (err == LFS3_ERR_NOENT) {
-                mdir_[i^l].rbyd.weight = 0;
+                mdir_[i^l].r.weight = 0;
             }
         }
 
@@ -8963,36 +8963,36 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
         LFS3_INFO("Splitting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} "
                     "-> 0x{%"PRIx32",%"PRIx32"}, 0x{%"PRIx32",%"PRIx32"}",
                 lfs3_dbgmbid(lfs3, mdir->mid),
-                mdir->rbyd.blocks[0], mdir->rbyd.blocks[1],
-                mdir_[0].rbyd.blocks[0], mdir_[0].rbyd.blocks[1],
-                mdir_[1].rbyd.blocks[0], mdir_[1].rbyd.blocks[1]);
+                mdir->r.blocks[0], mdir->r.blocks[1],
+                mdir_[0].r.blocks[0], mdir_[0].r.blocks[1],
+                mdir_[1].r.blocks[0], mdir_[1].r.blocks[1]);
 
         // because of defered commits, children can be reduced to zero
         // when splitting, need to catch this here
 
         // both siblings reduced to zero
-        if (mdir_[0].rbyd.weight == 0 && mdir_[1].rbyd.weight == 0) {
+        if (mdir_[0].r.weight == 0 && mdir_[1].r.weight == 0) {
             LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}",
                     lfs3_dbgmbid(lfs3, mdir_[0].mid),
-                    mdir_[0].rbyd.blocks[0], mdir_[0].rbyd.blocks[1]);
+                    mdir_[0].r.blocks[0], mdir_[0].r.blocks[1]);
             LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}",
                     lfs3_dbgmbid(lfs3, mdir_[1].mid),
-                    mdir_[1].rbyd.blocks[0], mdir_[1].rbyd.blocks[1]);
+                    mdir_[1].r.blocks[0], mdir_[1].r.blocks[1]);
             goto dropped;
 
         // one sibling reduced to zero
-        } else if (mdir_[0].rbyd.weight == 0) {
+        } else if (mdir_[0].r.weight == 0) {
             LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}",
                     lfs3_dbgmbid(lfs3, mdir_[0].mid),
-                    mdir_[0].rbyd.blocks[0], mdir_[0].rbyd.blocks[1]);
+                    mdir_[0].r.blocks[0], mdir_[0].r.blocks[1]);
             lfs3_mdir_sync(&mdir_[0], &mdir_[1]);
             goto relocated;
 
         // other sibling reduced to zero
-        } else if (mdir_[1].rbyd.weight == 0) {
+        } else if (mdir_[1].r.weight == 0) {
             LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}",
                     lfs3_dbgmbid(lfs3, mdir_[1].mid),
-                    mdir_[1].rbyd.blocks[0], mdir_[1].rbyd.blocks[1]);
+                    mdir_[1].r.blocks[0], mdir_[1].r.blocks[1]);
             goto relocated;
         }
 
@@ -9004,7 +9004,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
         // note we need to do this after playing out pending rattrs in
         // case they introduce a new name!
         lfs3_data_t split_name;
-        err = lfs3_rbyd_lookup(lfs3, &mdir_[1].rbyd, 0,
+        err = lfs3_rbyd_lookup(lfs3, &mdir_[1].r, 0,
                 LFS3_TAG_MASK8 | LFS3_TAG_NAME,
                 NULL, &split_name);
         if (err) {
@@ -9020,13 +9020,13 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                     0, LFS3_RATTRS(
                         LFS3_RATTR_MPTR(
                             LFS3_TAG_MDIR, +(1 << lfs3->mbits),
-                            mdir_[0].rbyd.blocks),
+                            mdir_[0].r.blocks),
                         LFS3_RATTR_DATA(
                             LFS3_TAG_MNAME, +(1 << lfs3->mbits),
                             &split_name),
                         LFS3_RATTR_MPTR(
                             LFS3_TAG_MDIR, 0,
-                            mdir_[1].rbyd.blocks)));
+                            mdir_[1].r.blocks)));
             if (err) {
                 goto failed;
             }
@@ -9040,13 +9040,13 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                     lfs3_mbid(lfs3, mdir->mid), LFS3_RATTRS(
                         LFS3_RATTR_MPTR(
                             LFS3_TAG_MDIR, 0,
-                            mdir_[0].rbyd.blocks),
+                            mdir_[0].r.blocks),
                         LFS3_RATTR_DATA(
                             LFS3_TAG_MNAME, +(1 << lfs3->mbits),
                             &split_name),
                         LFS3_RATTR_MPTR(
                             LFS3_TAG_MDIR, 0,
-                            mdir_[1].rbyd.blocks)));
+                            mdir_[1].r.blocks)));
             if (err) {
                 goto failed;
             }
@@ -9056,9 +9056,9 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
     } else if (err == LFS3_ERR_NOENT) {
         LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}",
                 lfs3_dbgmbid(lfs3, mdir->mid),
-                mdir->rbyd.blocks[0], mdir->rbyd.blocks[1]);
+                mdir->r.blocks[0], mdir->r.blocks[1]);
         // set weight to zero
-        mdir_[0].rbyd.weight = 0;
+        mdir_[0].r.weight = 0;
 
         // consume gstate so we don't lose any info
         err = lfs3_fs_consumegdelta(lfs3, mdir);
@@ -9090,8 +9090,8 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
         LFS3_INFO("Relocating mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} "
                     "-> 0x{%"PRIx32",%"PRIx32"}",
                 lfs3_dbgmbid(lfs3, mdir->mid),
-                mdir->rbyd.blocks[0], mdir->rbyd.blocks[1],
-                mdir_[0].rbyd.blocks[0], mdir_[0].rbyd.blocks[1]);
+                mdir->r.blocks[0], mdir->r.blocks[1],
+                mdir_[0].r.blocks[0], mdir_[0].r.blocks[1]);
 
     relocated:;
         // new mtree?
@@ -9102,7 +9102,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                     0, LFS3_RATTRS(
                         LFS3_RATTR_MPTR(
                             LFS3_TAG_MDIR, +(1 << lfs3->mbits),
-                            mdir_[0].rbyd.blocks)));
+                            mdir_[0].r.blocks)));
             if (err) {
                 goto failed;
             }
@@ -9116,7 +9116,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                     lfs3_mbid(lfs3, mdir->mid), LFS3_RATTRS(
                         LFS3_RATTR_MPTR(
                             LFS3_TAG_MDIR, 0,
-                            mdir_[0].rbyd.blocks)));
+                            mdir_[0].r.blocks)));
             if (err) {
                 goto failed;
             }
@@ -9130,9 +9130,9 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                 == lfs3_mbid(lfs3, lfs3_smax(mdir->mid, 0))) {
             if (mdelta > 0
                     && lfs3_mrid(lfs3, lfs3->grm.queue[j])
-                        >= (lfs3_srid_t)mdir_[0].rbyd.weight) {
+                        >= (lfs3_srid_t)mdir_[0].r.weight) {
                 lfs3->grm.queue[j]
-                        += (1 << lfs3->mbits) - mdir_[0].rbyd.weight;
+                        += (1 << lfs3->mbits) - mdir_[0].r.weight;
             }
         } else if (lfs3->grm.queue[j] > mdir->mid) {
             lfs3->grm.queue[j] += mdelta;
@@ -9154,7 +9154,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
 
         // xor mroot's cksum if we haven't already
         if (lfs3_mdir_cmp(mdir, &lfs3->mroot) != 0) {
-            lfs3->gcksum ^= lfs3->mroot.rbyd.cksum;
+            lfs3->gcksum ^= lfs3->mroot.r.cksum;
         }
 
         // commit new mtree into our mroot
@@ -9187,7 +9187,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                 && !lfs3_mdir_ismrootanchor(&mrootchild)) {
             // find the mroot's parent
             lfs3_mdir_t mrootparent;
-            err = lfs3_mroot_parent(lfs3, mrootchild.rbyd.blocks,
+            err = lfs3_mroot_parent(lfs3, mrootchild.r.blocks,
                     &mrootparent);
             if (err) {
                 LFS3_ASSERT(err != LFS3_ERR_NOENT);
@@ -9196,8 +9196,8 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
 
             LFS3_INFO("Relocating mroot 0x{%"PRIx32",%"PRIx32"} "
                         "-> 0x{%"PRIx32",%"PRIx32"}",
-                    mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1],
-                    mrootchild_.rbyd.blocks[0], mrootchild_.rbyd.blocks[1]);
+                    mrootchild.r.blocks[0], mrootchild.r.blocks[1],
+                    mrootchild_.r.blocks[0], mrootchild_.r.blocks[1]);
 
             // make sure mtree/mroot changes are on-disk before committing
             // metadata
@@ -9207,7 +9207,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
             }
 
             // xor mrootparent's cksum
-            lfs3->gcksum ^= mrootparent.rbyd.cksum;
+            lfs3->gcksum ^= mrootparent.r.cksum;
 
             // commit mrootchild
             lfs3_mdir_t mrootparent_;
@@ -9216,7 +9216,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                     -1, LFS3_RATTRS(
                         LFS3_RATTR_MPTR(
                             LFS3_TAG_MROOT, 0,
-                            mrootchild_.rbyd.blocks)));
+                            mrootchild_.r.blocks)));
             if (err) {
                 LFS3_ASSERT(err != LFS3_ERR_RANGE);
                 LFS3_ASSERT(err != LFS3_ERR_NOENT);
@@ -9233,9 +9233,9 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
             LFS3_ASSERT(lfs3_mdir_ismrootanchor(&mrootchild));
             LFS3_INFO("Extending mroot 0x{%"PRIx32",%"PRIx32"}"
                         " -> 0x{%"PRIx32",%"PRIx32"}, 0x{%"PRIx32",%"PRIx32"}",
-                    mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1],
-                    mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1],
-                    mrootchild_.rbyd.blocks[0], mrootchild_.rbyd.blocks[1]);
+                    mrootchild.r.blocks[0], mrootchild.r.blocks[1],
+                    mrootchild.r.blocks[0], mrootchild.r.blocks[1],
+                    mrootchild_.r.blocks[0], mrootchild_.r.blocks[1]);
 
             // make sure mtree/mroot changes are on-disk before committing
             // metadata
@@ -9251,8 +9251,8 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                 // bad prog? can't do much here, mroot stuck
                 if (err == LFS3_ERR_CORRUPT) {
                     LFS3_ERROR("Stuck mroot 0x{%"PRIx32",%"PRIx32"}",
-                            mrootanchor_.rbyd.blocks[0],
-                            mrootanchor_.rbyd.blocks[1]);
+                            mrootanchor_.r.blocks[0],
+                            mrootanchor_.r.blocks[1]);
                     return LFS3_ERR_NOSPC;
                 }
                 goto failed;
@@ -9265,15 +9265,15 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                             "littlefs", 8),
                         LFS3_RATTR_MPTR(
                             LFS3_TAG_MROOT, 0,
-                            mrootchild_.rbyd.blocks)));
+                            mrootchild_.r.blocks)));
             if (err) {
                 LFS3_ASSERT(err != LFS3_ERR_RANGE);
                 LFS3_ASSERT(err != LFS3_ERR_NOENT);
                 // bad prog? can't do much here, mroot stuck
                 if (err == LFS3_ERR_CORRUPT) {
                     LFS3_ERROR("Stuck mroot 0x{%"PRIx32",%"PRIx32"}",
-                            mrootanchor_.rbyd.blocks[0],
-                            mrootanchor_.rbyd.blocks[1]);
+                            mrootanchor_.r.blocks[0],
+                            mrootanchor_.r.blocks[1]);
                     return LFS3_ERR_NOSPC;
                 }
                 goto failed;
@@ -9343,8 +9343,8 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
         if (lfs3_mdir_cmp(&o->mdir, mdir) == 0) {
             if (mdelta > 0
                     && lfs3_mrid(lfs3, o->mdir.mid)
-                        >= (lfs3_srid_t)mdir_[0].rbyd.weight) {
-                o->mdir.mid += (1 << lfs3->mbits) - mdir_[0].rbyd.weight;
+                        >= (lfs3_srid_t)mdir_[0].r.weight) {
+                o->mdir.mid += (1 << lfs3->mbits) - mdir_[0].r.weight;
                 lfs3_mdir_sync(&o->mdir, &mdir_[1]);
             } else {
                 lfs3_mdir_sync(&o->mdir, &mdir_[0]);
@@ -9360,8 +9360,8 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
         lfs3_mdir_sync(mdir, &mroot_);
     } else if (mdelta > 0
             && lfs3_mrid(lfs3, mdir->mid)
-                >= (lfs3_srid_t)mdir_[0].rbyd.weight) {
-        mdir->mid += (1 << lfs3->mbits) - mdir_[0].rbyd.weight;
+                >= (lfs3_srid_t)mdir_[0].r.weight) {
+        mdir->mid += (1 << lfs3->mbits) - mdir_[0].r.weight;
         lfs3_mdir_sync(mdir, &mdir_[1]);
     } else {
         lfs3_mdir_sync(mdir, &mdir_[0]);
@@ -9408,10 +9408,10 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir,
                 "0x{%"PRIx32",%"PRIx32"}.%"PRIx32" w%"PRId32", "
                 "cksum %"PRIx32,
             lfs3_dbgmbid(lfs3, mdir->mid),
-            mdir->rbyd.blocks[0], mdir->rbyd.blocks[1],
-            lfs3_rbyd_trunk(&mdir->rbyd),
-            mdir->rbyd.weight,
-            mdir->rbyd.cksum);
+            mdir->r.blocks[0], mdir->r.blocks[1],
+            lfs3_rbyd_trunk(&mdir->r),
+            mdir->r.weight,
+            mdir->r.cksum);
     #endif
     return 0;
 
@@ -9448,13 +9448,13 @@ static int lfs3_mdir_namelookup(lfs3_t *lfs3, const lfs3_mdir_t *mdir,
     }
 
     // empty mdir?
-    if (mdir->rbyd.weight == 0) {
+    if (mdir->r.weight == 0) {
         return LFS3_ERR_NOENT;
     }
 
     lfs3_srid_t rid;
     lfs3_tag_t tag;
-    lfs3_scmp_t cmp = lfs3_rbyd_namelookup(lfs3, &mdir->rbyd,
+    lfs3_scmp_t cmp = lfs3_rbyd_namelookup(lfs3, &mdir->r,
             did, name, name_len,
             &rid, &tag, NULL, data_);
     if (cmp < 0) {
@@ -9503,7 +9503,7 @@ static int lfs3_mtree_namelookup(lfs3_t *lfs3,
         lfs3_data_t data;
         lfs3_scmp_t cmp = lfs3_btree_namelookupleaf(lfs3, &lfs3->mtree,
                 did, name, name_len,
-                &bid, &mdir_->rbyd, &rid, &tag, &weight, &data);
+                &bid, &mdir_->r, &rid, &tag, &weight, &data);
         if (cmp < 0) {
             LFS3_ASSERT(cmp != LFS3_ERR_NOENT);
             return cmp;
@@ -9514,7 +9514,7 @@ static int lfs3_mtree_namelookup(lfs3_t *lfs3,
 
         // if we found an mname, lookup the mdir
         if (tag == LFS3_TAG_MNAME) {
-            int err = lfs3_rbyd_lookup(lfs3, &mdir_->rbyd, rid, LFS3_TAG_MDIR,
+            int err = lfs3_rbyd_lookup(lfs3, &mdir_->r, rid, LFS3_TAG_MDIR,
                     NULL, &data);
             if (err) {
                 LFS3_ASSERT(err != LFS3_ERR_NOENT);
@@ -9722,9 +9722,9 @@ static void lfs3_traversal_init(lfs3_traversal_t *t, uint32_t flags) {
             | lfs3_t_tstateflags(LFS3_TSTATE_MROOTANCHOR)
             | flags;
     t->b.o.mdir.mid = -1;
-    t->b.o.mdir.rbyd.weight = 0;
-    t->b.o.mdir.rbyd.blocks[0] = -1;
-    t->b.o.mdir.rbyd.blocks[1] = -1;
+    t->b.o.mdir.r.weight = 0;
+    t->b.o.mdir.r.blocks[0] = -1;
+    t->b.o.mdir.r.blocks[1] = -1;
     lfs3_bshrub_init(&t->b);
     t->ot = NULL;
     t->u.mtortoise.blocks[0] = -1;
@@ -9759,7 +9759,7 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
             if (tag_) {
                 *tag_ = LFS3_TAG_MDIR;
             }
-            bptr->data.u.buffer = (const uint8_t*)&t->b.o.mdir;
+            bptr->d.u.buffer = (const uint8_t*)&t->b.o.mdir;
             return 0;
 
         // traverse the mroot chain, checking for mroots/mtrees
@@ -9798,17 +9798,17 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
                 // so creating a valid cycle is actually quite difficult
                 //
                 if (lfs3_mptr_cmp(
-                        t->b.o.mdir.rbyd.blocks,
+                        t->b.o.mdir.r.blocks,
                         t->u.mtortoise.blocks) == 0) {
                     LFS3_ERROR("Cycle detected during mtree traversal "
                                 "0x{%"PRIx32",%"PRIx32"}",
-                            t->b.o.mdir.rbyd.blocks[0],
-                            t->b.o.mdir.rbyd.blocks[1]);
+                            t->b.o.mdir.r.blocks[0],
+                            t->b.o.mdir.r.blocks[1]);
                     return LFS3_ERR_CORRUPT;
                 }
                 if (t->u.mtortoise.step == (1U << t->u.mtortoise.power)) {
-                    t->u.mtortoise.blocks[0] = t->b.o.mdir.rbyd.blocks[0];
-                    t->u.mtortoise.blocks[1] = t->b.o.mdir.rbyd.blocks[1];
+                    t->u.mtortoise.blocks[0] = t->b.o.mdir.r.blocks[0];
+                    t->u.mtortoise.blocks[1] = t->b.o.mdir.r.blocks[1];
                     t->u.mtortoise.step = 0;
                     t->u.mtortoise.power += 1;
                 }
@@ -9817,7 +9817,7 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
                 if (tag_) {
                     *tag_ = LFS3_TAG_MDIR;
                 }
-                bptr->data.u.buffer = (const uint8_t*)&t->b.o.mdir;
+                bptr->d.u.buffer = (const uint8_t*)&t->b.o.mdir;
                 return 0;
 
             // found an mtree?
@@ -9862,7 +9862,7 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
             if (tag_) {
                 *tag_ = LFS3_TAG_MDIR;
             }
-            bptr->data.u.buffer = (const uint8_t*)&t->b.o.mdir;
+            bptr->d.u.buffer = (const uint8_t*)&t->b.o.mdir;
             return 0;
         #endif
 
@@ -9873,7 +9873,7 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
             // return to mtree iteration
             if (lfs3_t_ismtreeonly(t->b.o.flags)
                     || lfs3_mrid(lfs3, t->b.o.mdir.mid)
-                        >= (lfs3_srid_t)t->b.o.mdir.rbyd.weight) {
+                        >= (lfs3_srid_t)t->b.o.mdir.r.weight) {
                 t->b.o.mdir.mid = lfs3_mbid(lfs3, t->b.o.mdir.mid) + 1;
                 lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIRS);
                 continue;
@@ -9983,7 +9983,7 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t,
                 if (tag_) {
                     *tag_ = tag;
                 }
-                bptr->data = data;
+                bptr->d = data;
                 return 0;
 
             // found an indirect block?
@@ -10046,39 +10046,39 @@ static int lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t,
     if ((lfs3_t_isckmeta(t->b.o.flags)
                 || lfs3_t_isckdata(t->b.o.flags))
             && tag == LFS3_TAG_MDIR) {
-        lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->data.u.buffer;
+        lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->d.u.buffer;
 
         // check cksum matches our mroot
         if (lfs3_mdir_cmp(mdir, &lfs3->mroot) == 0
-                && mdir->rbyd.cksum != lfs3->mroot.rbyd.cksum) {
+                && mdir->r.cksum != lfs3->mroot.r.cksum) {
             LFS3_ERROR("Found mroot cksum mismatch "
                         "0x{%"PRIx32",%"PRIx32"}, "
                         "cksum %08"PRIx32" (!= %08"PRIx32")",
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1],
-                    mdir->rbyd.cksum,
-                    lfs3->mroot.rbyd.cksum);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1],
+                    mdir->r.cksum,
+                    lfs3->mroot.r.cksum);
             return LFS3_ERR_CORRUPT;
         }
 
         // check cksum matches any open mdirs
         for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) {
             if (lfs3_mdir_cmp(&o->mdir, mdir) == 0
-                    && o->mdir.rbyd.cksum != mdir->rbyd.cksum) {
+                    && o->mdir.r.cksum != mdir->r.cksum) {
                 LFS3_ERROR("Found mdir cksum mismatch %"PRId32" "
                             "0x{%"PRIx32",%"PRIx32"}, "
                             "cksum %08"PRIx32" (!= %08"PRIx32")",
                         lfs3_dbgmbid(lfs3, mdir->mid),
-                        mdir->rbyd.blocks[0],
-                        mdir->rbyd.blocks[1],
-                        mdir->rbyd.cksum,
-                        o->mdir.rbyd.cksum);
+                        mdir->r.blocks[0],
+                        mdir->r.blocks[1],
+                        mdir->r.cksum,
+                        o->mdir.r.cksum);
                 return LFS3_ERR_CORRUPT;
             }
         }
 
         // recalculate gcksum
-        t->gcksum ^= mdir->rbyd.cksum;
+        t->gcksum ^= mdir->r.cksum;
     }
 
     // validate btree nodes?
@@ -10089,7 +10089,7 @@ static int lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t,
     if ((lfs3_t_isckmeta(t->b.o.flags)
                 || lfs3_t_isckdata(t->b.o.flags))
             && tag == LFS3_TAG_BRANCH) {
-        lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr->data.u.buffer;
+        lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr->d.u.buffer;
         err = lfs3_rbyd_fetchck(lfs3, rbyd,
                 rbyd->blocks[0], rbyd->trunk,
                 rbyd->cksum);
@@ -10184,7 +10184,7 @@ dropped:;
     if (lfs3_t_ismkconsistent(t->b.o.flags)
             && lfs3_t_ismkconsistent(lfs3->flags)
             && tag == LFS3_TAG_MDIR) {
-        lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->data.u.buffer;
+        lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->d.u.buffer;
         err = lfs3_mdir_mkconsistent(lfs3, mdir);
         if (err) {
             goto failed;
@@ -10195,7 +10195,7 @@ dropped:;
 
         // did this drop our mdir?
         #ifndef LFS3_2BONLY
-        if (mdir->mid != -1 && mdir->rbyd.weight == 0) {
+        if (mdir->mid != -1 && mdir->r.weight == 0) {
             // swap back dirty/mutated flags
             t->b.o.flags = lfs3_t_swapdirty(t->b.o.flags);
             // continue traversal
@@ -10209,17 +10209,17 @@ dropped:;
     if (lfs3_t_iscompact(t->b.o.flags)
             && tag == LFS3_TAG_MDIR
             // exceed compaction threshold?
-            && lfs3_rbyd_eoff(&((lfs3_mdir_t*)bptr->data.u.buffer)->rbyd)
+            && lfs3_rbyd_eoff(&((lfs3_mdir_t*)bptr->d.u.buffer)->r)
                 > ((lfs3->cfg->gc_compact_thresh)
                     ? lfs3->cfg->gc_compact_thresh
                     : lfs3->cfg->block_size - lfs3->cfg->block_size/8)) {
-        lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->data.u.buffer;
+        lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->d.u.buffer;
         LFS3_INFO("Compacting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} "
                     "(%"PRId32" > %"PRId32")",
                 lfs3_dbgmbid(lfs3, mdir->mid),
-                mdir->rbyd.blocks[0],
-                mdir->rbyd.blocks[1],
-                lfs3_rbyd_eoff(&mdir->rbyd),
+                mdir->r.blocks[0],
+                mdir->r.blocks[1],
+                lfs3_rbyd_eoff(&mdir->r),
                 (lfs3->cfg->gc_compact_thresh)
                     ? lfs3->cfg->gc_compact_thresh
                     : lfs3->cfg->block_size - lfs3->cfg->block_size/8);
@@ -10333,12 +10333,12 @@ static void lfs3_alloc_markinuse_(lfs3_t *lfs3, lfs3_block_t block) {
 static void lfs3_alloc_markinuse(lfs3_t *lfs3,
         lfs3_tag_t tag, const lfs3_bptr_t *bptr) {
     if (tag == LFS3_TAG_MDIR) {
-        lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->data.u.buffer;
-        lfs3_alloc_markinuse_(lfs3, mdir->rbyd.blocks[0]);
-        lfs3_alloc_markinuse_(lfs3, mdir->rbyd.blocks[1]);
+        lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->d.u.buffer;
+        lfs3_alloc_markinuse_(lfs3, mdir->r.blocks[0]);
+        lfs3_alloc_markinuse_(lfs3, mdir->r.blocks[1]);
 
     } else if (tag == LFS3_TAG_BRANCH) {
-        lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr->data.u.buffer;
+        lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr->d.u.buffer;
         lfs3_alloc_markinuse_(lfs3, rbyd->blocks[0]);
 
     } else if (tag == LFS3_TAG_BLOCK) {
@@ -10712,7 +10712,7 @@ static int lfs3_grm_pushdid(lfs3_t *lfs3, lfs3_did_t did) {
     // check that the directory is empty
     bookmark_mdir.mid += 1;
     if (lfs3_mrid(lfs3, bookmark_mdir.mid)
-            >= (lfs3_srid_t)bookmark_mdir.rbyd.weight) {
+            >= (lfs3_srid_t)bookmark_mdir.r.weight) {
         err = lfs3_mtree_lookup(lfs3,
                 lfs3_mbid(lfs3, bookmark_mdir.mid-1) + 1,
                 &bookmark_mdir);
@@ -10974,7 +10974,7 @@ int lfs3_rename(lfs3_t *lfs3, const char *old_path, const char *new_path) {
 
     if (old_tag == LFS3_TAG_UNKNOWN) {
         // lookup the actual tag
-        err = lfs3_rbyd_lookup(lfs3, &old_mdir.rbyd,
+        err = lfs3_rbyd_lookup(lfs3, &old_mdir.r,
                 lfs3_mrid(lfs3, old_mdir.mid), LFS3_TAG_MASK8 | LFS3_TAG_NAME,
                 &old_tag, NULL);
         if (err) {
@@ -11218,7 +11218,7 @@ int lfs3_dir_read(lfs3_t *lfs3, lfs3_dir_t *dir, struct lfs3_info *info) {
     while (true) {
         // next mdir?
         if (lfs3_mrid(lfs3, dir->o.mdir.mid)
-                >= (lfs3_srid_t)dir->o.mdir.rbyd.weight) {
+                >= (lfs3_srid_t)dir->o.mdir.r.weight) {
             int err = lfs3_mtree_lookup(lfs3,
                     lfs3_mbid(lfs3, dir->o.mdir.mid-1) + 1,
                     &dir->o.mdir);
@@ -11291,7 +11291,7 @@ int lfs3_dir_seek(lfs3_t *lfs3, lfs3_dir_t *dir, lfs3_soff_t off) {
     while (off_ > 0) {
         // next mdir?
         if (lfs3_mrid(lfs3, dir->o.mdir.mid)
-                >= (lfs3_srid_t)dir->o.mdir.rbyd.weight) {
+                >= (lfs3_srid_t)dir->o.mdir.r.weight) {
             int err = lfs3_mtree_lookup(lfs3,
                     lfs3_mbid(lfs3, dir->o.mdir.mid-1) + 1,
                     &dir->o.mdir);
@@ -11305,7 +11305,7 @@ int lfs3_dir_seek(lfs3_t *lfs3, lfs3_dir_t *dir, lfs3_soff_t off) {
 
         lfs3_off_t d = lfs3_min(
                 off_,
-                dir->o.mdir.rbyd.weight
+                dir->o.mdir.r.weight
                     - lfs3_mrid(lfs3, dir->o.mdir.mid));
         dir->o.mdir.mid += d;
         off_ -= d;
@@ -11988,7 +11988,7 @@ static lfs3_ssize_t lfs3_file_readnext(lfs3_t *lfs3, lfs3_file_t *file,
                         size,
                         lfs3_bptr_size(&file->leaf.bptr)
                             - (pos_ - file->leaf.pos));
-                lfs3_data_t slice = LFS3_DATA_SLICE(file->leaf.bptr.data,
+                lfs3_data_t slice = LFS3_DATA_SLICE(file->leaf.bptr.d,
                         pos_ - file->leaf.pos,
                         d);
                 d = lfs3_data_read(lfs3, &slice,
@@ -12065,7 +12065,7 @@ static lfs3_ssize_t lfs3_file_readget_(lfs3_t *lfs3, lfs3_file_t *file,
                     size,
                     lfs3_bptr_size(&bptr)
                         - (pos_ - (bid-(weight-1))));
-            lfs3_data_t slice = LFS3_DATA_SLICE(bptr.data,
+            lfs3_data_t slice = LFS3_DATA_SLICE(bptr.d,
                     pos_ - (bid-(weight-1)),
                     d);
             d = lfs3_data_read(lfs3, &slice,
@@ -12288,11 +12288,11 @@ static int lfs3_file_graft_(lfs3_t *lfs3, lfs3_file_t *file,
 
         // note, an entry can be both a left and right sibling
         l = bptr_;
-        l.data = LFS3_DATA_SLICE(bptr_.data,
+        l.d = LFS3_DATA_SLICE(bptr_.d,
                 -1,
                 pos - (bid-(weight_-1)));
         r = bptr_;
-        r.data = LFS3_DATA_SLICE(bptr_.data,
+        r.d = LFS3_DATA_SLICE(bptr_.d,
                 pos+weight - (bid-(weight_-1)),
                 -1);
 
@@ -12310,7 +12310,7 @@ static int lfs3_file_graft_(lfs3_t *lfs3, lfs3_file_t *file,
                 rattrs[rattr_count++] = LFS3_RATTR_DATA(
                         LFS3_TAG_GROW | LFS3_TAG_MASK8 | LFS3_TAG_DATA,
                             -(bid+1 - pos),
-                        &l.data);
+                        &l.d);
 
             // carve bptr?
             } else {
@@ -12357,7 +12357,7 @@ static int lfs3_file_graft_(lfs3_t *lfs3, lfs3_file_t *file,
                     || lfs3_bptr_size(&r) <= lfs3->cfg->fragment_size) {
                 r_rattr_ = LFS3_RATTR_DATA(
                         LFS3_TAG_DATA, bid+1 - (pos+weight),
-                        &r.data);
+                        &r.d);
 
             // carve bptr?
             } else {
@@ -12576,7 +12576,7 @@ static int lfs3_file_crystallize__(lfs3_t *lfs3, lfs3_file_t *file,
                     err = lfs3_bd_progdata(lfs3,
                             lfs3_bptr_block(&file->leaf.bptr),
                             pos_ - block_pos,
-                            LFS3_DATA_SLICE(bptr__.data,
+                            LFS3_DATA_SLICE(bptr__.d,
                                 pos_ - (bid__-(weight__-1)),
                                 d_),
                             &cksum_, true);
@@ -12713,7 +12713,7 @@ static int lfs3_file_crystallize_(lfs3_t *lfs3, lfs3_file_t *file,
     // and graft into tree
     err = lfs3_file_graft_(lfs3, file,
             file->leaf.pos, file->leaf.weight, 0,
-            &file->leaf.bptr.data, LFS3_GRAFT_ISBPTR | 1);
+            &file->leaf.bptr.d, LFS3_GRAFT_ISBPTR | 1);
     if (err) {
         goto failed;
     }
@@ -13160,7 +13160,7 @@ fragment:;
             if (bid-(weight-1) + lfs3_bptr_size(&bptr) >= fragment_start
                     && fragment_end - (bid-(weight-1))
                         <= lfs3->cfg->fragment_size) {
-                datas[data_count++] = LFS3_DATA_TRUNCATE(bptr.data,
+                datas[data_count++] = LFS3_DATA_TRUNCATE(bptr.d,
                         fragment_start - (bid-(weight-1)));
 
                 fragment_start = bid-(weight-1);
@@ -13197,7 +13197,7 @@ fragment:;
                     && bid-(weight-1) + lfs3_bptr_size(&bptr)
                             - fragment_start
                         <= lfs3->cfg->fragment_size) {
-                datas[data_count++] = LFS3_DATA_FRUNCATE(bptr.data,
+                datas[data_count++] = LFS3_DATA_FRUNCATE(bptr.d,
                         bid-(weight-1) + lfs3_bptr_size(&bptr)
                             - fragment_end);
 
@@ -13480,7 +13480,7 @@ static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file,
         // not created yet? need to convert to normal file
         } else if (lfs3_o_isuncreat(file->b.o.flags)) {
             // convert stickynote -> reg file
-            int err = lfs3_rbyd_lookup(lfs3, &file->b.o.mdir.rbyd,
+            int err = lfs3_rbyd_lookup(lfs3, &file->b.o.mdir.r,
                     lfs3_mrid(lfs3, file->b.o.mdir.mid), LFS3_TAG_STICKYNOTE,
                     NULL, &name_data);
             if (err) {
@@ -13920,8 +13920,8 @@ int lfs3_file_truncate(lfs3_t *lfs3, lfs3_file_t *file, lfs3_off_t size_) {
     //
     // note we don't unconditionally discard to match fruncate, where we
     // _really_ don't want to discard erased-state
-    file->leaf.bptr.data = LFS3_DATA_TRUNCATE(
-            file->leaf.bptr.data,
+    file->leaf.bptr.d = LFS3_DATA_TRUNCATE(
+            file->leaf.bptr.d,
             size_ - lfs3_min(file->leaf.pos, size_));
     file->leaf.weight = lfs3_min(
             file->leaf.weight,
@@ -14003,8 +14003,8 @@ int lfs3_file_fruncate(lfs3_t *lfs3, lfs3_file_t *file, lfs3_off_t size_) {
     // note we _really_ don't want to discard erased-state if possible,
     // as fruncate is intended for logging operations, otherwise we'd
     // just unconditionally discard the leaf and avoid this hassle
-    file->leaf.bptr.data = LFS3_DATA_FRUNCATE(
-            file->leaf.bptr.data,
+    file->leaf.bptr.d = LFS3_DATA_FRUNCATE(
+            file->leaf.bptr.d,
             lfs3_bptr_size(&file->leaf.bptr) - lfs3_min(
                 lfs3_smax(
                     size - size_ - file->leaf.pos,
@@ -14939,8 +14939,8 @@ static int lfs3_mountinited(lfs3_t *lfs3) {
     // mark mroot as invalid to prevent lfs3_mtree_traverse from getting
     // confused
     lfs3->mroot.mid = -1;
-    lfs3->mroot.rbyd.blocks[0] = -1;
-    lfs3->mroot.rbyd.blocks[1] = -1;
+    lfs3->mroot.r.blocks[0] = -1;
+    lfs3->mroot.r.blocks[1] = -1;
 
     // default to no mtree, this is allowed and implies all files are inlined
     // in the mroot
@@ -14973,7 +14973,7 @@ static int lfs3_mountinited(lfs3_t *lfs3) {
 
         // found an mdir?
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             // found an mroot?
             if (mdir->mid == -1) {
                 // check for the magic string, all mroot should have this
@@ -15017,7 +15017,7 @@ static int lfs3_mountinited(lfs3_t *lfs3) {
             }
 
             // build gcksum out of mdir cksums
-            lfs3->gcksum ^= mdir->rbyd.cksum;
+            lfs3->gcksum ^= mdir->r.cksum;
 
             // collect any gdeltas from this mdir
             err = lfs3_fs_consumegdelta(lfs3, mdir);
@@ -15028,7 +15028,7 @@ static int lfs3_mountinited(lfs3_t *lfs3) {
         // found an mtree inner-node?
         } else if (LFS3_IFDEF_2BONLY(false, tag == LFS3_TAG_BRANCH)) {
             #ifndef LFS3_2BONLY
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             // found the root of the mtree? keep track of this
             if (lfs3->mtree.weight == 0) {
                 lfs3->mtree = *rbyd;
@@ -15240,9 +15240,9 @@ int lfs3_mount(lfs3_t *lfs3, uint32_t flags,
             LFS3_DISK_VERSION_MINOR,
             lfs3->cfg->block_size,
             lfs3->block_count,
-            lfs3->mroot.rbyd.blocks[0],
-            lfs3->mroot.rbyd.blocks[1],
-            lfs3_rbyd_trunk(&lfs3->mroot.rbyd),
+            lfs3->mroot.r.blocks[0],
+            lfs3->mroot.r.blocks[1],
+            lfs3_rbyd_trunk(&lfs3->mroot.r),
             LFS3_IFDEF_2BONLY(0, lfs3->mtree.weight) >> lfs3->mbits,
             1 << lfs3->mbits,
             lfs3->gcksum);
@@ -15581,7 +15581,7 @@ static int lfs3_mdir_mkconsistent(lfs3_t *lfs3, lfs3_mdir_t *mdir) {
     // iterate through mids looking for orphans
     mdir->mid = LFS3_MID(lfs3, mdir->mid, 0);
     int err;
-    while (lfs3_mrid(lfs3, mdir->mid) < (lfs3_srid_t)mdir->rbyd.weight) {
+    while (lfs3_mrid(lfs3, mdir->mid) < (lfs3_srid_t)mdir->r.weight) {
         // is this mid open? well we're not an orphan then, skip
         //
         // note we can't rely on lfs3_mdir_lookup's internal orphan
@@ -15593,7 +15593,7 @@ static int lfs3_mdir_mkconsistent(lfs3_t *lfs3, lfs3_mdir_t *mdir) {
         }
 
         // is this mid marked as a stickynote?
-        err = lfs3_rbyd_lookup(lfs3, &mdir->rbyd,
+        err = lfs3_rbyd_lookup(lfs3, &mdir->r,
                 lfs3_mrid(lfs3, mdir->mid), LFS3_TAG_STICKYNOTE,
                 NULL, NULL);
         if (err) {
@@ -16028,14 +16028,14 @@ int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t,
 
         // figure out type/blocks
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             lfs3_t_setbtype(&t->b.o.flags, LFS3_BTYPE_MDIR);
-            t->blocks[0] = mdir->rbyd.blocks[0];
-            t->blocks[1] = mdir->rbyd.blocks[1];
+            t->blocks[0] = mdir->r.blocks[0];
+            t->blocks[1] = mdir->r.blocks[1];
 
         } else if (tag == LFS3_TAG_BRANCH) {
             lfs3_t_setbtype(&t->b.o.flags, LFS3_BTYPE_BTREE);
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             t->blocks[0] = rbyd->blocks[0];
             t->blocks[1] = -1;
 
diff --git a/lfs3.h b/lfs3.h
index 95725bde..28a23cae 100644
--- a/lfs3.h
+++ b/lfs3.h
@@ -655,7 +655,7 @@ typedef struct lfs3_bptr {
     // sign2(size)=0b00 => in-RAM buffer
     // sign2(size)=0b10 => on-disk data
     // sign2(size)=0b11 => block pointer
-    lfs3_data_t data;
+    lfs3_data_t d;
     #if !defined(LFS3_2BONLY) && !defined(LFS3_CKDATACKSUMREADS)
     // sign(cksize)=0 => block not erased
     // sign(cksize)=1 => block erased
@@ -687,7 +687,7 @@ typedef lfs3_rbyd_t lfs3_btree_t;
 // littlefs's atomic metadata log type
 typedef struct lfs3_mdir {
     lfs3_smid_t mid;
-    lfs3_rbyd_t rbyd;
+    lfs3_rbyd_t r;
     uint32_t gcksumdelta;
 } lfs3_mdir_t;
 
diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml
index ce9b264d..45477518 100644
--- a/tests/test_alloc.toml
+++ b/tests/test_alloc.toml
@@ -198,18 +198,18 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8] |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8] |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -369,18 +369,18 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8] |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8] |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -391,11 +391,11 @@ code = '''
         } else if (tag == LFS3_TAG_BLOCK) {
             printf("traversal: 0x%x block 0x%x\n",
                     tag,
-                    bptr.data.u.disk.block);
+                    bptr.d.u.disk.block);
 
             // keep track of seen blocks
-            seen[bptr.data.u.disk.block / 8]
-                    |= 1 << (bptr.data.u.disk.block % 8);
+            seen[bptr.d.u.disk.block / 8]
+                    |= 1 << (bptr.d.u.disk.block % 8);
 
         } else {
             // this shouldn't happen
@@ -526,20 +526,20 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8]
-                    |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8]
-                    |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8]
+                    |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8]
+                    |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -551,11 +551,11 @@ code = '''
         } else if (tag == LFS3_TAG_BLOCK) {
             printf("traversal: 0x%x block 0x%x\n",
                     tag,
-                    bptr.data.u.disk.block);
+                    bptr.d.u.disk.block);
 
             // keep track of seen blocks
-            seen[bptr.data.u.disk.block / 8]
-                    |= 1 << (bptr.data.u.disk.block % 8);
+            seen[bptr.d.u.disk.block / 8]
+                    |= 1 << (bptr.d.u.disk.block % 8);
 
         } else {
             // this shouldn't happen
diff --git a/tests/test_fwrite.toml b/tests/test_fwrite.toml
index cca7c685..f1a1ba6c 100644
--- a/tests/test_fwrite.toml
+++ b/tests/test_fwrite.toml
@@ -226,9 +226,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // we disabled block crystallization so this shouldn't
                 // happen
@@ -375,9 +375,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // keep track of how many data blocks we've seen
                 blocks += 1;
@@ -640,9 +640,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // we disabled block crystallization so this shouldn't
                 // happen
@@ -804,9 +804,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // keep track of how many data blocks we've seen
                 blocks += 1;
@@ -2131,9 +2131,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // all blocks should have been fragmented
                 assert(false);
@@ -2283,9 +2283,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // all blocks should have been fragmented
                 assert(false);
@@ -2582,9 +2582,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // we disabled block crystallization so this shouldn't
                 // happen
@@ -2750,9 +2750,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // keep track of how many data blocks we've seen
                 blocks += 1;
@@ -3042,9 +3042,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // we disabled block crystallization so this shouldn't
                 // happen
@@ -3214,9 +3214,9 @@ code = '''
                         bid,
                         tag,
                         weight,
-                        bptr.data.u.disk.block,
-                        bptr.data.u.disk.off,
-                        lfs3_data_size(bptr.data));
+                        lfs3_bptr_block(&bptr),
+                        lfs3_bptr_off(&bptr),
+                        lfs3_bptr_size(&bptr));
 
                 // keep track of how many data blocks we've seen
                 blocks += 1;
diff --git a/tests/test_gc.toml b/tests/test_gc.toml
index 05856926..dd7a01fd 100644
--- a/tests/test_gc.toml
+++ b/tests/test_gc.toml
@@ -184,7 +184,7 @@ code = '''
 
     // hack, don't use the internals like this
     uint8_t wbuf[SIZE];
-    while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -213,7 +213,7 @@ code = '''
     }
 
     // mdir should have been compacted
-    assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // check we can still read the file
     for (int remount = 0; remount < 2; remount++) {
@@ -273,7 +273,7 @@ code = '''
 
     // hack, don't use the internals like this
     uint8_t wbuf[SIZE];
-    while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
diff --git a/tests/test_mount.toml b/tests/test_mount.toml
index 4c3ce1a7..17040aab 100644
--- a/tests/test_mount.toml
+++ b/tests/test_mount.toml
@@ -203,7 +203,7 @@ code = '''
 
     // hack, don't use the internals like this
     uint8_t wbuf[SIZE];
-    while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -245,7 +245,7 @@ code = '''
 
     // mdir should have been compacted
     lfs3_file_open(&lfs3, &file, "jellyfish", LFS3_O_RDONLY) => 0;
-    assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // check we can still read the file
     uint8_t rbuf[SIZE];
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index ddc94e39..a13223bf 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -90,7 +90,7 @@ code = '''
 
     for (lfs3_size_t i = 0; i < N; i++) {
         // force mroot to compact
-        lfs3.mroot.rbyd.eoff = -1;
+        lfs3.mroot.r.eoff = -1;
 
         lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
                 LFS3_RATTR_BUF(
@@ -196,14 +196,14 @@ code = '''
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, buffer, SIZE))) => 0;
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
     lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0;
@@ -211,7 +211,7 @@ code = '''
     assert(buffer[0] == 'a');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
@@ -227,7 +227,7 @@ code = '''
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
     lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0;
@@ -235,7 +235,7 @@ code = '''
     assert(buffer[0] == 'a');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
@@ -269,7 +269,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -278,27 +278,27 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -314,17 +314,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -358,7 +358,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -367,17 +367,17 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // now add another large entry to an mdir, forcing a split
     memset(buffer+1, 'd', SIZE-1);
@@ -387,27 +387,27 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mdir to compact
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "e", 1))) => 0;
 
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -417,7 +417,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
@@ -433,17 +433,17 @@ code = '''
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -453,7 +453,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
@@ -487,8 +487,8 @@ code = '''
                 &mdir, NULL, NULL) => LFS3_ERR_NOENT;
         // force a compaction?
         if (FORCE_COMPACTION) {
-            lfs3.mroot.rbyd.eoff = -1;
-            mdir.rbyd.eoff = -1;
+            lfs3.mroot.r.eoff = -1;
+            mdir.r.eoff = -1;
         }
         lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
                 LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0;
@@ -512,7 +512,7 @@ code = '''
         name[0] = '\0';
         sprintf(name+1, "%03x", i);
         mdir.mid += 1;
-        if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.rbyd.weight) {
+        if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.r.weight) {
             lfs3_mtree_lookup(&lfs3, lfs3_mbid(&lfs3, mdir.mid) + 1,
                     &mdir) => 0;
         }
@@ -534,7 +534,7 @@ code = '''
         name[0] = '\0';
         sprintf(name+1, "%03x", i);
         mdir.mid += 1;
-        if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.rbyd.weight) {
+        if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.r.weight) {
             lfs3_mtree_lookup(&lfs3, lfs3_mbid(&lfs3, mdir.mid) + 1,
                     &mdir) => 0;
         }
@@ -585,8 +585,8 @@ code = '''
         }
         // force a compaction?
         if (FORCE_COMPACTION) {
-            lfs3.mroot.rbyd.eoff = -1;
-            mdir.rbyd.eoff = -1;
+            lfs3.mroot.r.eoff = -1;
+            mdir.r.eoff = -1;
         }
         lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
                 LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0;
@@ -675,7 +675,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -684,17 +684,17 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // remove an entry, forcing the mdir to be dropped
     memset(buffer+1, 'b', SIZE-1);
@@ -702,16 +702,16 @@ code = '''
             &mdir, NULL, NULL) => 0;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 0);
+    assert(mdir.r.weight == 0);
 
     // assert mdir was dropped
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -727,11 +727,11 @@ code = '''
     // assert mdir was dropped
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -765,7 +765,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -774,36 +774,36 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // remove an entry, forcing the mdir to be dropped
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     // force mdir to compact while we're removing
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 0);
+    assert(mdir.r.weight == 0);
 
     // assert mdir was dropped
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -819,11 +819,11 @@ code = '''
     // assert mdir was dropped
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -857,7 +857,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -866,27 +866,27 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // remove an entry, forcing the mdir to be dropped
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     // force mdir to compact while we're removing
-    lfs3.mroot.rbyd.eoff = -1;
-    mdir.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // assert split/drop worked out
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -898,11 +898,11 @@ code = '''
     // assert mdir was dropped
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -932,7 +932,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -941,17 +941,17 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // now add another large entry to an mdir, forcing a split
     memset(buffer+1, 'd', SIZE-1);
@@ -961,26 +961,26 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // remove an entry, forcing the mdir to be dropped
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     // force mdir to compact while we're removing
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
 
     // assert split/drop worked out
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -990,7 +990,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
@@ -1002,11 +1002,11 @@ code = '''
     // assert split/drop worked out
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -1016,7 +1016,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
@@ -1046,7 +1046,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -1055,17 +1055,17 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // now add another large entry to an mdir, forcing a split
     memset(buffer+1, 'd', SIZE-1);
@@ -1075,32 +1075,32 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // remove an entry, forcing the mdir to be dropped
     memset(buffer+1, 'd', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     // force mdir to compact while we're removing
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
 
     // assert split/drop worked out
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -1116,17 +1116,17 @@ code = '''
     // assert split/drop worked out
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -1180,8 +1180,8 @@ code = '''
             }
             // force a compaction?
             if (FORCE_COMPACTION) {
-                lfs3.mroot.rbyd.eoff = -1;
-                mdir.rbyd.eoff = -1;
+                lfs3.mroot.r.eoff = -1;
+                mdir.r.eoff = -1;
             }
             lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
                     LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0;
@@ -1208,8 +1208,8 @@ code = '''
             }
             // force a compaction?
             if (FORCE_COMPACTION) {
-                lfs3.mroot.rbyd.eoff = -1;
-                mdir.rbyd.eoff = -1;
+                lfs3.mroot.r.eoff = -1;
+                mdir.r.eoff = -1;
             }
             lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
                     LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
@@ -1296,22 +1296,22 @@ code = '''
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, buffer, SIZE))) => 0;
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // force mdir to compact twice, this should relocate
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
     lfs3_mdir_t old_mdir = mdir;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "d", 1))) => 0;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(5), 0, "e", 1))) => 0;
     // assert we relocated
@@ -1320,7 +1320,7 @@ code = '''
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
     lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0;
@@ -1328,7 +1328,7 @@ code = '''
     assert(buffer[0] == 'a');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
@@ -1338,7 +1338,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(4), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
@@ -1354,7 +1354,7 @@ code = '''
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
     lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0;
@@ -1362,7 +1362,7 @@ code = '''
     assert(buffer[0] == 'a');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
@@ -1372,7 +1372,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(4), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
@@ -1408,7 +1408,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -1417,27 +1417,27 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // force mdir to compact twice, this should relocate
     memset(buffer+1, 'a', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     lfs3_mdir_t old_mdir = mdir;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0;
     // assert we relocated
@@ -1446,17 +1446,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -1466,7 +1466,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
@@ -1482,17 +1482,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -1502,7 +1502,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
@@ -1538,7 +1538,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -1547,27 +1547,27 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // force mdir to compact twice, this should relocate
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     lfs3_mdir_t old_mdir = mdir;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0;
     // assert we relocated
@@ -1576,17 +1576,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -1596,7 +1596,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
@@ -1612,17 +1612,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -1632,7 +1632,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
@@ -1668,14 +1668,14 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0;
     // assert we relocated
@@ -1683,7 +1683,7 @@ code = '''
 
     // assert that our entry is still in the mroot
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -1702,7 +1702,7 @@ code = '''
 
     // assert that our rattr is still in the mroot
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -1745,14 +1745,14 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0;
     // assert we relocated
@@ -1761,16 +1761,16 @@ code = '''
     // force mroot to compact four times, this should relocate the mroot
     // twice, forcing a second mroot extension
     old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "d", 1))) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "e", 1))) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(5), 0, "f", 1))) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(6), 0, "g", 1))) => 0;
     // assert we relocated
@@ -1778,7 +1778,7 @@ code = '''
 
     // assert that our rattr is still in the mroot
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -1813,7 +1813,7 @@ code = '''
 
     // assert that our rattr is still in the mroot
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -1869,14 +1869,14 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0;
     // assert we relocated
@@ -1884,10 +1884,10 @@ code = '''
 
     // force mroot to compact twice again, this should relocate the mroot
     old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "d", 1))) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "e", 1))) => 0;
     // assert we relocated
@@ -1895,7 +1895,7 @@ code = '''
 
     // assert that our entry is still in the mroot
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -1922,7 +1922,7 @@ code = '''
 
     // assert that our rattr is still in the mroot
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -1970,7 +1970,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -1979,30 +1979,30 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // setup mroot to compact and relocate on next commit
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_t old_mroot = lfs3.mroot;
     // force mdir to compact twice, this should relocate
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     lfs3_mdir_t old_mdir = mdir;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0;
     // assert we relocated
@@ -2013,17 +2013,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -2033,7 +2033,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
@@ -2049,17 +2049,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -2069,7 +2069,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, 1) => 1;
     assert(buffer[0] == 'd');
@@ -2105,7 +2105,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -2114,17 +2114,17 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // now add another large entry to an mdir, forcing a split
     memset(buffer+1, 'd', SIZE-1);
@@ -2134,17 +2134,17 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // setup mroot to compact and relocate on next commit
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_t old_mroot = lfs3.mroot;
     // force mdir to compact twice, this should relocate
     lfs3_mdir_t old_mdir = mdir;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "e", 1))) => 0;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "f", 1))) => 0;
     // assert we relocated
@@ -2155,17 +2155,17 @@ code = '''
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -2175,7 +2175,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
@@ -2195,17 +2195,17 @@ code = '''
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -2215,7 +2215,7 @@ code = '''
     assert(buffer[0] == 'c');
 
     lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'd');
@@ -2255,7 +2255,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -2264,45 +2264,45 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // setup mroot to compact and relocate on next commit
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_t old_mroot = lfs3.mroot;
     // remove an entry, forcing the mdir to be dropped
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     // force mdir to compact twice, this should relocate
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0;
     // force mdir to compact while we're removing
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 0);
+    assert(mdir.r.weight == 0);
     // assert mroot relocated
     assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0);
 
     // assert mdir was dropped
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -2318,11 +2318,11 @@ code = '''
     // assert mdir was dropped
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -2348,7 +2348,7 @@ code = '''
 
     // force mroot to compact once, so the second compact below will
     // trigger a relocation
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
     lfs3_data_t data;
 
@@ -2366,7 +2366,7 @@ code = '''
 
     // force mroot to compact, this should both uninline and relocate
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0;
     // assert mroot relocated
@@ -2375,7 +2375,7 @@ code = '''
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
     lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0;
@@ -2383,7 +2383,7 @@ code = '''
     assert(buffer[0] == 'a');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
@@ -2399,7 +2399,7 @@ code = '''
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
     lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0;
@@ -2407,7 +2407,7 @@ code = '''
     assert(buffer[0] == 'a');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
@@ -2433,7 +2433,7 @@ code = '''
 
     // force mroot to compact once, so the second compact below will
     // trigger a relocation
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
     lfs3_data_t data;
 
@@ -2448,7 +2448,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -2457,11 +2457,11 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact, this should both split and relocate
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0;
     // assert mroot relocated
@@ -2470,17 +2470,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -2496,17 +2496,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -2562,8 +2562,8 @@ code = '''
             }
             // force a compaction?
             if (FORCE_COMPACTION) {
-                lfs3.mroot.rbyd.eoff = -1;
-                mdir.rbyd.eoff = -1;
+                lfs3.mroot.r.eoff = -1;
+                mdir.r.eoff = -1;
             }
             lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
                     LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0;
@@ -2589,8 +2589,8 @@ code = '''
             }
             // force a compaction?
             if (FORCE_COMPACTION) {
-                lfs3.mroot.rbyd.eoff = -1;
-                mdir.rbyd.eoff = -1;
+                lfs3.mroot.r.eoff = -1;
+                mdir.r.eoff = -1;
             }
             // we can't really change metadata names, but commits still
             // trigger writes to the mdir
@@ -2619,8 +2619,8 @@ code = '''
             }
             // force a compaction?
             if (FORCE_COMPACTION) {
-                lfs3.mroot.rbyd.eoff = -1;
-                mdir.rbyd.eoff = -1;
+                lfs3.mroot.r.eoff = -1;
+                mdir.r.eoff = -1;
             }
             lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
                     LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
@@ -2694,7 +2694,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -2702,7 +2702,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "c", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // insert a new entry, this should update our neighbors
@@ -2711,7 +2711,7 @@ code = '''
             &mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
     lfs3_data_t data;
 
     // assert our entry was created
@@ -2725,14 +2725,14 @@ code = '''
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
     lfs3_mtree_namelookup(&lfs3, 0, "c", 1,
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -2753,7 +2753,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -2761,7 +2761,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // try removing left neighbor
@@ -2770,7 +2770,7 @@ code = '''
             &mdir, NULL, NULL) => 0;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // assert neighbor was removed
     lfs3_mtree_namelookup(&lfs3, 0, "a", 1,
@@ -2781,8 +2781,8 @@ code = '''
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -2803,7 +2803,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -2811,7 +2811,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // try removing right neighbor
@@ -2820,7 +2820,7 @@ code = '''
             &mdir, NULL, NULL) => 0;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // assert neighbor was removed
     lfs3_mtree_namelookup(&lfs3, 0, "b", 1,
@@ -2831,8 +2831,8 @@ code = '''
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -2855,7 +2855,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -2863,7 +2863,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // create 2 large entries that needs to be uninlined and split
@@ -2877,7 +2877,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -2886,30 +2886,30 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 5);
+    assert(mdir.r.weight == 5);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our neighbors were updated correctly
     lfs3_mtree_namelookup(&lfs3, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
     lfs3_mtree_namelookup(&lfs3, 0, "d", 1,
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -2932,7 +2932,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -2940,7 +2940,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "e", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // create 2 large entries that needs to be uninlined and split
@@ -2954,7 +2954,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     memset(buffer+1, 'd', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -2963,10 +2963,10 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 5);
+    assert(mdir.r.weight == 5);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // now add another large entry to an mdir, forcing a split
@@ -2977,30 +2977,30 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     // force mdir to compact
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our neighbors were updated correctly
     lfs3_mtree_namelookup(&lfs3, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
     lfs3_mtree_namelookup(&lfs3, 0, "e", 1,
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -3023,7 +3023,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -3031,14 +3031,14 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // force mroot to compact twice, this should extend the mroot
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
     // assert we relocated
     assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0);
@@ -3049,14 +3049,14 @@ code = '''
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
     lfs3_mtree_namelookup(&lfs3, 0, "b", 1,
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -3081,7 +3081,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -3089,7 +3089,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // create 2 large entries that needs to be uninlined and split
@@ -3103,7 +3103,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -3112,28 +3112,28 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 5);
+    assert(mdir.r.weight == 5);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // force mdir to compact twice, this should relocate
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     lfs3_mdir_t old_mdir = mdir;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, 0,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, 0,
@@ -3146,14 +3146,14 @@ code = '''
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
     lfs3_mtree_namelookup(&lfs3, 0, "d", 1,
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -3178,7 +3178,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -3186,7 +3186,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // create 2 large entries that needs to be uninlined and split
@@ -3200,7 +3200,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -3209,28 +3209,28 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 5);
+    assert(mdir.r.weight == 5);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // force mdir to compact twice, this should relocate
     memset(buffer+1, 'c', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
     lfs3_mdir_t old_mdir = mdir;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, 0,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, 0,
@@ -3243,14 +3243,14 @@ code = '''
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
     lfs3_mtree_namelookup(&lfs3, 0, "d", 1,
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -3273,7 +3273,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -3281,7 +3281,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "f", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // create 2 large entries that needs to be uninlined and split
@@ -3295,7 +3295,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     memset(buffer+1, 'e', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -3304,10 +3304,10 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 5);
+    assert(mdir.r.weight == 5);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // now add another large entry to an mdir, forcing a split
@@ -3318,16 +3318,16 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     // force mdir to compact
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // now add _another_ large entry to the middle mdir, forcing another split
     memset(buffer+1, 'd', SIZE-1);
@@ -3337,30 +3337,30 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mdir to compact
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (4 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our neighbors were updated correctly
     lfs3_mtree_namelookup(&lfs3, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
     lfs3_mtree_namelookup(&lfs3, 0, "f", 1,
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -3383,7 +3383,7 @@ code = '''
             &left.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(left.mdir.rbyd.weight == 2);
+    assert(left.mdir.r.weight == 2);
     lfs3_omdir_open(&lfs3, &left);
 
     lfs3_omdir_t right = {.flags=0};
@@ -3391,7 +3391,7 @@ code = '''
             &right.mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "e", 1))) => 0;
-    assert(right.mdir.rbyd.weight == 3);
+    assert(right.mdir.r.weight == 3);
     lfs3_omdir_open(&lfs3, &right);
 
     // create 2 large entries that needs to be uninlined and split
@@ -3405,7 +3405,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     memset(buffer+1, 'd', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -3414,10 +3414,10 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 5);
+    assert(mdir.r.weight == 5);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // now add another large entry to an mdir, forcing a split
@@ -3428,40 +3428,40 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 4);
+    assert(mdir.r.weight == 4);
 
     // force mdir to compact
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // now remove the middle entry, forcing a drop
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR(LFS3_TAG_RM, -1))) => 0;
-    assert(mdir.rbyd.weight == 0);
+    assert(mdir.r.weight == 0);
 
     // assert mdir was dropped correctly
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our neighbors were updated correctly
     lfs3_mtree_namelookup(&lfs3, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
     assert(left.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0);
-    assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(left.mdir.r.trunk == mdir.r.trunk);
+    assert(left.mdir.r.cksum == mdir.r.cksum);
     lfs3_mtree_namelookup(&lfs3, 0, "e", 1,
             &mdir, NULL, NULL) => 0;
     assert(right.mdir.mid == mdir.mid);
     assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0);
-    assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk);
-    assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum);
+    assert(right.mdir.r.trunk == mdir.r.trunk);
+    assert(right.mdir.r.cksum == mdir.r.cksum);
 
     lfs3_omdir_close(&lfs3, &left);
     lfs3_omdir_close(&lfs3, &right);
@@ -3487,7 +3487,7 @@ code = '''
             &mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // test that we can traverse the tree, keeping track of all blocks we see
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
@@ -3512,18 +3512,18 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8] |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8] |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -3599,13 +3599,13 @@ code = '''
             LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, buffer, SIZE))) => 0;
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // test that we can traverse the tree, keeping track of all blocks we see
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
@@ -3630,18 +3630,18 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8] |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8] |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -3672,7 +3672,7 @@ code = '''
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
     lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0;
@@ -3680,7 +3680,7 @@ code = '''
     assert(buffer[0] == 'a');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(1), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
@@ -3692,7 +3692,7 @@ code = '''
     // assert mdirs were unininlined
     assert(lfs3.mtree.weight == (1 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our rattrs are still in the mroot/mtree
     lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0;
@@ -3700,7 +3700,7 @@ code = '''
     assert(buffer[0] == 'a');
 
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(1), NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'b');
@@ -3731,7 +3731,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -3740,16 +3740,16 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // test that we can traverse the tree, keeping track of all blocks we see
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
@@ -3774,18 +3774,18 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8] |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8] |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -3816,17 +3816,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -3838,17 +3838,17 @@ code = '''
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
@@ -3879,7 +3879,7 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1,
@@ -3888,16 +3888,16 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 3);
+    assert(mdir.r.weight == 3);
 
     // force mroot to compact
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfs3.mtree.weight == (2 << lfs3.mbits));
     // assert mroot now has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // now add another large entry to an mdir, forcing a split
     memset(buffer+1, 'c', SIZE-1);
@@ -3907,16 +3907,16 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mdir to compact
-    mdir.rbyd.eoff = -1;
+    mdir.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0;
 
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // test that we can traverse the tree, keeping track of all blocks we see
     uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
@@ -3941,18 +3941,18 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8] |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8] |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -3983,23 +3983,23 @@ code = '''
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
@@ -4011,23 +4011,23 @@ code = '''
     // assert mdir was split correctly
     assert(lfs3.mtree.weight == (3 << lfs3.mbits));
     // assert mroot still has no entries
-    assert(lfs3.mroot.rbyd.weight == 0);
+    assert(lfs3.mroot.r.weight == 0);
 
     // assert that our entries are still in the mtree
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
 
     lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'b');
 
     lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0;
-    assert(mdir.rbyd.weight == 1);
+    assert(mdir.r.weight == 1);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'c');
@@ -4052,13 +4052,13 @@ code = '''
             &mdir, NULL, NULL) => LFS3_ERR_NOENT;
     lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
             LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
     // assert we relocated
     assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0);
@@ -4086,20 +4086,20 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8]
-                    |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8]
-                    |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8]
+                    |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8]
+                    |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -4173,8 +4173,8 @@ code = '''
                 &mdir, NULL, NULL) => LFS3_ERR_NOENT;
         // force a compaction?
         if (FORCE_COMPACTION) {
-            lfs3.mroot.rbyd.eoff = -1;
-            mdir.rbyd.eoff = -1;
+            lfs3.mroot.r.eoff = -1;
+            mdir.r.eoff = -1;
         }
         lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
                 LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0;
@@ -4209,20 +4209,20 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8]
-                    |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8]
-                    |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8]
+                    |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8]
+                    |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -4263,7 +4263,7 @@ code = '''
         name[0] = '\0';
         sprintf(name+1, "%03x", i);
         mdir.mid += 1;
-        if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.rbyd.weight) {
+        if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.r.weight) {
             lfs3_mtree_lookup(&lfs3, lfs3_mbid(&lfs3, mdir.mid) + 1,
                     &mdir) => 0;
         }
@@ -4285,7 +4285,7 @@ code = '''
         name[0] = '\0';
         sprintf(name+1, "%03x", i);
         mdir.mid += 1;
-        if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.rbyd.weight) {
+        if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.r.weight) {
             lfs3_mtree_lookup(&lfs3, lfs3_mbid(&lfs3, mdir.mid) + 1,
                     &mdir) => 0;
         }
@@ -4336,8 +4336,8 @@ code = '''
         }
         // force a compaction?
         if (FORCE_COMPACTION) {
-            lfs3.mroot.rbyd.eoff = -1;
-            mdir.rbyd.eoff = -1;
+            lfs3.mroot.r.eoff = -1;
+            mdir.r.eoff = -1;
         }
         lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(
                 LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0;
@@ -4374,20 +4374,20 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
             // keep track of seen blocks
-            seen[mdir->rbyd.blocks[1] / 8]
-                    |= 1 << (mdir->rbyd.blocks[1] % 8);
-            seen[mdir->rbyd.blocks[0] / 8]
-                    |= 1 << (mdir->rbyd.blocks[0] % 8);
+            seen[mdir->r.blocks[1] / 8]
+                    |= 1 << (mdir->r.blocks[1] % 8);
+            seen[mdir->r.blocks[0] / 8]
+                    |= 1 << (mdir->r.blocks[0] % 8);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -4501,14 +4501,14 @@ code = '''
         }
 
         if (tag == LFS3_TAG_MDIR) {
-            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer;
+            lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x mdir 0x{%x,%x}\n",
                     tag,
-                    mdir->rbyd.blocks[0],
-                    mdir->rbyd.blocks[1]);
+                    mdir->r.blocks[0],
+                    mdir->r.blocks[1]);
 
         } else if (tag == LFS3_TAG_BRANCH) {
-            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer;
+            lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer;
             printf("traversal: 0x%x btree 0x%x.%x\n",
                     tag,
                     rbyd->blocks[0], rbyd->trunk);
@@ -4810,20 +4810,20 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
     // assert we relocated
     assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0);
 
     // assert that our entry is still in the mroot
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
@@ -4869,13 +4869,13 @@ code = '''
             LFS3_RATTR_NAME(
                 LFS3_TAG_REG, +1,
                 0, (const char*)buffer+1, SIZE-1))) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfs3_mdir_t old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
     // assert we relocated
     assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0);
@@ -4883,20 +4883,20 @@ code = '''
     // force mroot to compact four times, this should relocate the mroot
     // twice, forcing a second mroot extension
     old_mroot = lfs3.mroot;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
-    lfs3.mroot.rbyd.eoff = -1;
+    lfs3.mroot.r.eoff = -1;
     lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0;
     // assert we relocated
     assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0);
 
     // assert that our rattr is still in the mroot
     lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0;
-    assert(mdir.rbyd.weight == 2);
+    assert(mdir.r.weight == 2);
     lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0;
     lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE;
     assert(buffer[1] == 'a');
diff --git a/tests/test_stickynotes.toml b/tests/test_stickynotes.toml
index 05c25a67..c05662cb 100644
--- a/tests/test_stickynotes.toml
+++ b/tests/test_stickynotes.toml
@@ -8021,7 +8021,7 @@ code = '''
             <= ((1+lfs3_popc(BOOKENDS)) << lfs3.mbits));
     lfs3_mdir_t mdir;
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight <= 1+lfs3_popc(BOOKENDS));
+    assert(mdir.r.weight <= 1+lfs3_popc(BOOKENDS));
 
     // check that other files are unaffected
     for (int remount = 0; remount < 2; remount++) {
@@ -8160,7 +8160,7 @@ code = '''
             <= ((1+lfs3_popc(BOOKENDS)) << lfs3.mbits));
     lfs3_mdir_t mdir;
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight <= 1+lfs3_popc(BOOKENDS));
+    assert(mdir.r.weight <= 1+lfs3_popc(BOOKENDS));
 
     // check that other files are unaffected
     for (int remount = 0; remount < 2; remount++) {
@@ -8313,7 +8313,7 @@ code = '''
             <= ((1+lfs3_popc(BOOKENDS)) << lfs3.mbits));
     lfs3_mdir_t mdir;
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight <= 1+lfs3_popc(BOOKENDS));
+    assert(mdir.r.weight <= 1+lfs3_popc(BOOKENDS));
 
     // check that other files are unaffected
     for (int remount = 0; remount < 2; remount++) {
@@ -8472,7 +8472,7 @@ code = '''
             <= ((1+lfs3_popc(BOOKENDS)) << lfs3.mbits));
     lfs3_mdir_t mdir;
     lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0;
-    assert(mdir.rbyd.weight <= 1+lfs3_popc(BOOKENDS));
+    assert(mdir.r.weight <= 1+lfs3_popc(BOOKENDS));
 
     // check that other files are unaffected
     if (BOOKENDS & 0x1) {
diff --git a/tests/test_traversal.toml b/tests/test_traversal.toml
index 05617aa4..f05bfb78 100644
--- a/tests/test_traversal.toml
+++ b/tests/test_traversal.toml
@@ -3793,8 +3793,8 @@ code = '''
     assert(tinfo.block == 0 || tinfo.block == 1);
 
     // rewrite enough files for mroot to extend
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_open(&lfs3, &file, "uloborus",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -3899,8 +3899,8 @@ code = '''
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite enough files for mroot to extend
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_open(&lfs3, &file, "uloborus",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -3978,8 +3978,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // rewrite enough files for mroot to extend
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_open(&lfs3, &file, "uloborus",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -4001,9 +4001,9 @@ code = '''
     assert(tinfo.block == 0 || tinfo.block == 1);
 
     // rewrite enough files for mroot to relocate
-    lfs3_block_t orig = lfs3.mroot.rbyd.blocks[0];
-    while (lfs3.mroot.rbyd.blocks[0] == orig
-            || lfs3.mroot.rbyd.blocks[0] == orig) {
+    lfs3_block_t orig = lfs3.mroot.r.blocks[0];
+    while (lfs3.mroot.r.blocks[0] == orig
+            || lfs3.mroot.r.blocks[0] == orig) {
         lfs3_file_open(&lfs3, &file, "uloborus",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -4092,8 +4092,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // rewrite enough files for mroot to extend
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_open(&lfs3, &file, "uloborus",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -4125,9 +4125,9 @@ code = '''
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite enough files for mroot to relocate
-    lfs3_block_t orig = lfs3.mroot.rbyd.blocks[0];
-    while (lfs3.mroot.rbyd.blocks[0] == orig
-            || lfs3.mroot.rbyd.blocks[0] == orig) {
+    lfs3_block_t orig = lfs3.mroot.r.blocks[0];
+    while (lfs3.mroot.r.blocks[0] == orig
+            || lfs3.mroot.r.blocks[0] == orig) {
         lfs3_file_open(&lfs3, &file, "uloborus",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -4799,8 +4799,8 @@ code = '''
     assert(tinfo.block == 0 || tinfo.block == 1);
 
     // rewrite enough files for mroot to extend
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_open(&lfs3, &file, "vulsor",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -4997,8 +4997,8 @@ code = '''
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite enough files for mroot to extend
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_open(&lfs3, &file, "vulsor",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -5114,8 +5114,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // rewrite enough files for mroot to extend
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_open(&lfs3, &file, "vulsor",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -5159,9 +5159,9 @@ code = '''
     assert(tinfo.block == 0 || tinfo.block == 1);
 
     // rewrite enough files for mroot to relocate
-    orig = lfs3.mroot.rbyd.blocks[0];
-    while (lfs3.mroot.rbyd.blocks[0] == orig
-            || lfs3.mroot.rbyd.blocks[0] == orig) {
+    orig = lfs3.mroot.r.blocks[0];
+    while (lfs3.mroot.r.blocks[0] == orig
+            || lfs3.mroot.r.blocks[0] == orig) {
         lfs3_file_open(&lfs3, &file, "vulsor",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -5294,8 +5294,8 @@ code = '''
     lfs3_file_close(&lfs3, &file) => 0;
 
     // rewrite enough files for mroot to extend
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_open(&lfs3, &file, "vulsor",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -5367,9 +5367,9 @@ code = '''
     assert(tinfo.btype == LFS3_BTYPE_DATA);
 
     // rewrite enough files for mroot to relocate
-    orig = lfs3.mroot.rbyd.blocks[0];
-    while (lfs3.mroot.rbyd.blocks[0] == orig
-            || lfs3.mroot.rbyd.blocks[0] == orig) {
+    orig = lfs3.mroot.r.blocks[0];
+    while (lfs3.mroot.r.blocks[0] == orig
+            || lfs3.mroot.r.blocks[0] == orig) {
         lfs3_file_open(&lfs3, &file, "vulsor",
                 LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
         lfs3_file_close(&lfs3, &file) => 0;
@@ -5456,7 +5456,7 @@ code = '''
 
     // hack, don't use the internals like this
     uint8_t wbuf[SIZE];
-    while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5493,7 +5493,7 @@ code = '''
     lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
 
     // mdir should have been compacted
-    assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // but because we mutated, we're still marked as uncompacted
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -5515,7 +5515,7 @@ code = '''
     lfs3_traversal_close(&lfs3, &t) => 0;
 
     // mdir should have been compacted
-    assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // uncompacted flag should have been cleared
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -5568,8 +5568,8 @@ code = '''
             LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0;
 
     uint8_t wbuf[SIZE];
-    while (lfs3.mroot.rbyd.blocks[0] == 0
-            || lfs3.mroot.rbyd.blocks[0] == 1) {
+    while (lfs3.mroot.r.blocks[0] == 0
+            || lfs3.mroot.r.blocks[0] == 1) {
         lfs3_file_rewind(&lfs3, &file) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5584,7 +5584,7 @@ code = '''
         lfs3_mdir_t mrootanchor;
         lfs3_mdir_fetch(&lfs3, &mrootanchor,
                 -1, LFS3_MPTR_MROOTANCHOR()) => 0;
-        if (lfs3_rbyd_eoff(&mrootanchor.rbyd) > GC_COMPACT_THRESH) {
+        if (lfs3_rbyd_eoff(&mrootanchor.r) > GC_COMPACT_THRESH) {
             break;
         }
 
@@ -5632,7 +5632,7 @@ code = '''
     lfs3_mdir_t mrootanchor;
     lfs3_mdir_fetch(&lfs3, &mrootanchor,
             -1, LFS3_MPTR_MROOTANCHOR()) => 0;
-    assert(lfs3_rbyd_eoff(&mrootanchor.rbyd) <= GC_COMPACT_THRESH);
+    assert(lfs3_rbyd_eoff(&mrootanchor.r) <= GC_COMPACT_THRESH);
 
     // but because we mutated, we're still marked as uncompacted
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -5656,7 +5656,7 @@ code = '''
     // mrootanchor should have been compacted
     lfs3_mdir_fetch(&lfs3, &mrootanchor,
             -1, LFS3_MPTR_MROOTANCHOR()) => 0;
-    assert(lfs3_rbyd_eoff(&mrootanchor.rbyd) <= GC_COMPACT_THRESH);
+    assert(lfs3_rbyd_eoff(&mrootanchor.r) <= GC_COMPACT_THRESH);
 
     // uncompacted flag should have been cleared
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -5710,7 +5710,7 @@ code = '''
 
     // hack, don't use the internals like this
     uint8_t wbuf[SIZE];
-    while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5749,7 +5749,7 @@ code = '''
     lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
 
     // mdir should have been compacted
-    assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // but because we mutated, we're still marked as uncompacted
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -5771,7 +5771,7 @@ code = '''
     lfs3_traversal_close(&lfs3, &t) => 0;
 
     // mdir should have been compacted
-    assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // uncompacted flag should have been cleared
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -5847,7 +5847,7 @@ code = '''
                 &file1.b.o.mdir, -1, -1,
                 NULL);
         assert(estimate >= 0);
-        if ((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) > GC_COMPACT_THRESH
+        if ((file1.b.o.mdir.r.eoff & 0x7fffffff) > GC_COMPACT_THRESH
                 && estimate > BLOCK_SIZE/2) {
             break;
         }
@@ -5902,8 +5902,8 @@ code = '''
     lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
 
     // mdirs should have been compacted
-    assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // but because we mutated, we're still marked as uncompacted
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -5925,8 +5925,8 @@ code = '''
     lfs3_traversal_close(&lfs3, &t) => 0;
 
     // mdirs should have been compacted
-    assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // uncompacted flag should have been cleared
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -6036,7 +6036,7 @@ code = '''
     // write to each file until mdir >gc_compact_thresh full
     if (COMPACTSET & 0x1) {
         // hack, don't use the internals like this
-        while ((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+        while ((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
             lfs3_file_rewind(&lfs3, &file1) => 0;
             for (lfs3_size_t j = 0; j < SIZE; j++) {
                 wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -6048,7 +6048,7 @@ code = '''
 
     if (COMPACTSET & 0x2) {
         // hack, don't use the internals like this
-        while ((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+        while ((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
             lfs3_file_rewind(&lfs3, &file2) => 0;
             for (lfs3_size_t j = 0; j < SIZE; j++) {
                 wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -6060,7 +6060,7 @@ code = '''
 
     if (COMPACTSET & 0x4) {
         // hack, don't use the internals like this
-        while ((file3.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+        while ((file3.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
             lfs3_file_rewind(&lfs3, &file3) => 0;
             for (lfs3_size_t j = 0; j < SIZE; j++) {
                 wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -6117,9 +6117,9 @@ code = '''
 
     if (COMPACTSET) {
         // mdirs should have been compacted
-        assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-        assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-        assert((file3.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+        assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+        assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+        assert((file3.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
         // but because we mutated, we're still marked as uncompacted
         lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -6142,9 +6142,9 @@ code = '''
     lfs3_traversal_close(&lfs3, &t) => 0;
 
     // mdirs should have been compacted
-    assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file3.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file3.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // uncompacted flag should have been cleared
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -6279,7 +6279,7 @@ code = '''
                 &file2.b.o.mdir, -1, -1,
                 NULL);
         assert(estimate >= 0);
-        if ((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) > GC_COMPACT_THRESH
+        if ((file2.b.o.mdir.r.eoff & 0x7fffffff) > GC_COMPACT_THRESH
                 && estimate > BLOCK_SIZE/2) {
             break;
         }
@@ -6344,10 +6344,10 @@ code = '''
     lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT;
 
     // mdirs should have been compacted
-    assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file3.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file4.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file3.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file4.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // but because we mutated, we're still marked as uncompacted
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -6369,10 +6369,10 @@ code = '''
     lfs3_traversal_close(&lfs3, &t) => 0;
 
     // mdirs should have been compacted
-    assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file3.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file4.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file3.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file4.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // uncompacted flag should have been cleared
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -6536,8 +6536,8 @@ code = '''
 
     // which means there shouldn't be that many files left
     assert(lfs3.mtree.weight <= (2 << lfs3.mbits));
-    assert(file1.b.o.mdir.rbyd.weight <= 3);
-    assert(file2.b.o.mdir.rbyd.weight <= 3);
+    assert(file1.b.o.mdir.r.weight <= 3);
+    assert(file2.b.o.mdir.r.weight <= 3);
 
     // and we should be marked as consistent
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -6845,8 +6845,8 @@ code = '''
 
     // which means there shouldn't be that many files left
     assert(lfs3.mtree.weight <= (2 << lfs3.mbits));
-    assert(file1.b.o.mdir.rbyd.weight <= 3);
-    assert(file2.b.o.mdir.rbyd.weight <= 3);
+    assert(file1.b.o.mdir.r.weight <= 3);
+    assert(file2.b.o.mdir.r.weight <= 3);
 
     // and we should be marked as consistent
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -7009,8 +7009,8 @@ code = '''
 
     // which means there shouldn't be that many files left
     assert(lfs3.mtree.weight <= (2 << lfs3.mbits));
-    assert(file1.b.o.mdir.rbyd.weight <= 3);
-    assert(file2.b.o.mdir.rbyd.weight <= 3);
+    assert(file1.b.o.mdir.r.weight <= 3);
+    assert(file2.b.o.mdir.r.weight <= 3);
 
     // and we should be marked as consistent
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -7182,8 +7182,8 @@ code = '''
 
     // which means there shouldn't be that many files left
     assert(lfs3.mtree.weight <= (2 << lfs3.mbits));
-    assert(file1.b.o.mdir.rbyd.weight <= 3);
-    assert(file2.b.o.mdir.rbyd.weight <= 3);
+    assert(file1.b.o.mdir.r.weight <= 3);
+    assert(file2.b.o.mdir.r.weight <= 3);
 
     // and we should be marked as consistent
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -7355,8 +7355,8 @@ code = '''
 
     // which means there shouldn't be that many files left
     assert(lfs3.mtree.weight <= (2 << lfs3.mbits));
-    assert(file1.b.o.mdir.rbyd.weight <= 3);
-    assert(file2.b.o.mdir.rbyd.weight <= 3);
+    assert(file1.b.o.mdir.r.weight <= 3);
+    assert(file2.b.o.mdir.r.weight <= 3);
 
     // and we should be marked as consistent
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -7456,7 +7456,7 @@ code = '''
     // write to our mdirs until >gc_compact_thresh full
     //
     // hack, don't use the internals like this
-    while ((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file1) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -7465,7 +7465,7 @@ code = '''
         lfs3_file_sync(&lfs3, &file1) => 0;
     }
 
-    while ((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file2) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -7524,12 +7524,12 @@ code = '''
 
     // which means there shouldn't be that many files left
     assert(lfs3.mtree.weight <= (2 << lfs3.mbits));
-    assert(file1.b.o.mdir.rbyd.weight <= 3);
-    assert(file2.b.o.mdir.rbyd.weight <= 3);
+    assert(file1.b.o.mdir.r.weight <= 3);
+    assert(file2.b.o.mdir.r.weight <= 3);
 
     // mdirs should have been compacted
-    assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // we should be marked as consistent, but because we mutated, we're
     // still marked as uncompacted
@@ -7552,8 +7552,8 @@ code = '''
     lfs3_traversal_close(&lfs3, &t) => 0;
 
     // mdirs should have been compacted
-    assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // uncompacted flag should have been cleared
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;
@@ -7631,7 +7631,7 @@ code = '''
     // write to our mdirs until >gc_compact_thresh full
     //
     // hack, don't use the internals like this
-    while ((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file1) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -7640,7 +7640,7 @@ code = '''
         lfs3_file_sync(&lfs3, &file1) => 0;
     }
 
-    while ((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
+    while ((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
         lfs3_file_rewind(&lfs3, &file2) => 0;
         for (lfs3_size_t j = 0; j < SIZE; j++) {
             wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -7723,8 +7723,8 @@ code = '''
     }
 
     // mdirs should have been compacted
-    assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
-    assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file1.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
+    assert((file2.b.o.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
 
     // if we introduced actual orphans, we _must_ be marked as inconsistent
     lfs3_fs_stat(&lfs3, &fsinfo) => 0;