From 0bed3867d89ece90ff0731c51d08709c8bf4df7f Mon Sep 17 00:00:00 2001
From: Christopher Haster <geky@geky.net>
Date: Mon, 14 Jul 2025 15:12:51 -0500
Subject: [PATCH] Adopted more single-char field names

Limited to nested struct fields where the names don't really matter:

- bptr.data -> bptr.d
- mdir.rbyd -> mdir.r

Ok it actually just ended up those two.

This is on the tail end of some optimization work that ended up
abandoned because of maintainability concerns. But it did highlight that
struct nesting gets a bit out-of-control when trying to both optimize
stack allocations and respect C99's strict aliasing.

Consider further fragmenting lfs3_rbyd_t for fine-grain stack
allocations:

  typedef struct lfs3_rbyd {
      struct lfs3_rtrunkcksum {
          struct lfs3_rtrunk {
              lfs3_rid_t weight;
              struct lfs3_rtrunktrunk {
                  lfs3_block_t blocks[2];
                  lfs3_size_t trunk;
              } rtrunktrunk;
          } rtrunk;
          uint32_t cksum;
      } rtrunkcksum;
      lfs3_size_t eoff;
  } lfs3_rbyd_t;

Accessing fields just starts to get silly:

  rbyd.rtrunkcksum.rtrunk.trunktrunk.trunk

At least single-char field names keeps a little bit of readability:

  rbyd.ck.t.t.trunk

Or for some real examples:

- file->b.o.mdir.rbyd.weight -> file->b.o.mdir.r.weight
- bptr->data.u.disk.block -> bptr->d.u.disk.block
---
 lfs3.c                      | 430 +++++++++---------
 lfs3.h                      |   4 +-
 tests/test_alloc.toml       |  52 +--
 tests/test_fwrite.toml      |  60 +--
 tests/test_gc.toml          |   6 +-
 tests/test_mount.toml       |   4 +-
 tests/test_mtree.toml       | 844 ++++++++++++++++++------------------
 tests/test_stickynotes.toml |   8 +-
 tests/test_traversal.toml   | 168 +++----
 9 files changed, 788 insertions(+), 788 deletions(-)

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;