diff --git a/lfs.c b/lfs.c
index 88089b87..ea7e7e8d 100644
--- a/lfs.c
+++ b/lfs.c
@@ -1415,11 +1415,11 @@ enum lfsr_tag {
 
     // in-device only tags, these should never get written to disk
     LFSR_TAG_INTERNAL       = 0x0800,
-    LFSR_TAG_ATTRS          = 0x0800,
+    LFSR_TAG_RATTRS         = 0x0800,
     LFSR_TAG_SHRUBCOMMIT    = 0x0801,
     LFSR_TAG_SHRUBTRUNK     = 0x0802,
     LFSR_TAG_MOVE           = 0x0803,
-    LFSR_TAG_UATTRS         = 0x0804,
+    LFSR_TAG_ATTRS          = 0x0804,
 
     // some in-device only tag modifiers
     LFSR_TAG_RM             = 0x8000,
@@ -2199,7 +2199,7 @@ static int lfsr_bd_progdata(lfs_t *lfs,
 }
 
 // we can also treat leb128/lleb128 encoding has a high-level operation,
-// which is useful for building attrs
+// which is useful for building rattrs
 
 #define LFSR_LEB128_DSIZE  5
 
@@ -2246,7 +2246,7 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word,
 
 // operations on attribute lists
 
-typedef struct lfsr_attr {
+typedef struct lfsr_rattr {
     lfsr_tag_t tag;
     int16_t count;
     lfsr_srid_t weight;
@@ -2254,51 +2254,51 @@ typedef struct lfsr_attr {
     // sign(size)=1 => multiple concatenated datas
     // special tags => other things
     const void *cat;
-} lfsr_attr_t;
+} lfsr_rattr_t;
 
-#define LFSR_ATTR_(_tag, _weight, _cat, _count) \
-    ((lfsr_attr_t){ \
+#define LFSR_RATTR_(_tag, _weight, _cat, _count) \
+    ((lfsr_rattr_t){ \
         .tag=_tag, \
         .count=(uint16_t){_count}, \
         .weight=_weight, \
         .cat=_cat})
 
-#define LFSR_ATTR(_tag, _weight, _data) \
-    ((struct {lfsr_attr_t a;}){lfsr_attr(_tag, _weight, _data)}.a)
+#define LFSR_RATTR(_tag, _weight, _data) \
+    ((struct {lfsr_rattr_t a;}){lfsr_rattr(_tag, _weight, _data)}.a)
 
-static inline lfsr_attr_t lfsr_attr(
+static inline lfsr_rattr_t lfsr_rattr(
         lfsr_tag_t tag, lfsr_srid_t weight, lfsr_data_t data) {
     // only simple data works here
     LFS_ASSERT(lfsr_data_isbuf(data));
     LFS_ASSERT(lfsr_data_size(data) <= 0x7fff);
-    return (lfsr_attr_t){
+    return (lfsr_rattr_t){
         .tag=tag,
         .count=lfsr_data_size(data),
         .weight=weight,
         .cat=data.u.buffer};
 }
 
-#define LFSR_ATTR_CAT_(_tag, _weight, _datas, _data_count) \
-    ((lfsr_attr_t){ \
+#define LFSR_RATTR_CAT_(_tag, _weight, _datas, _data_count) \
+    ((lfsr_rattr_t){ \
         .tag=_tag, \
         .count=-(uint16_t){_data_count}, \
         .weight=_weight, \
         .cat=_datas})
 
-#define LFSR_ATTR_CAT(_tag, _weight, ...) \
-    LFSR_ATTR_CAT_( \
+#define LFSR_RATTR_CAT(_tag, _weight, ...) \
+    LFSR_RATTR_CAT_( \
         _tag, \
         _weight, \
         ((const lfsr_data_t[]){__VA_ARGS__}), \
         sizeof((const lfsr_data_t[]){__VA_ARGS__}) / sizeof(lfsr_data_t))
 
-#define LFSR_ATTR_NOOP() \
-    LFSR_ATTR_(LFSR_TAG_NULL, 0, NULL, 0)
+#define LFSR_RATTR_NOOP() \
+    LFSR_RATTR_(LFSR_TAG_NULL, 0, NULL, 0)
 
 // create an attribute list
-#define LFSR_ATTRS(...) \
-    (const lfsr_attr_t[]){__VA_ARGS__}, \
-    sizeof((const lfsr_attr_t[]){__VA_ARGS__}) / sizeof(lfsr_attr_t)
+#define LFSR_RATTRS(...) \
+    (const lfsr_rattr_t[]){__VA_ARGS__}, \
+    sizeof((const lfsr_rattr_t[]){__VA_ARGS__}) / sizeof(lfsr_rattr_t)
 
 // cat helpers
 static inline lfs_size_t lfsr_cat_size(const void *cat, int16_t count) {
@@ -2344,31 +2344,31 @@ static int lfsr_bd_progcat(lfs_t *lfs,
     }
 }
 
-// other attr helpers
-static inline bool lfsr_attr_isnoop(lfsr_attr_t attr) {
-    // noop attrs must have zero weight
-    LFS_ASSERT(attr.tag || attr.weight == 0);
-    return !attr.tag;
+// other rattr helpers
+static inline bool lfsr_rattr_isnoop(lfsr_rattr_t rattr) {
+    // noop rattrs must have zero weight
+    LFS_ASSERT(rattr.tag || rattr.weight == 0);
+    return !rattr.tag;
 }
 
-static inline bool lfsr_attr_isinsert(lfsr_attr_t attr) {
-    return !lfsr_tag_isgrow(attr.tag) && attr.weight > 0;
+static inline bool lfsr_rattr_isinsert(lfsr_rattr_t rattr) {
+    return !lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0;
 }
 
-static inline lfsr_srid_t lfsr_attr_nextrid(lfsr_attr_t attr,
+static inline lfsr_srid_t lfsr_rattr_nextrid(lfsr_rattr_t rattr,
         lfsr_srid_t rid) {
-    if (lfsr_attr_isinsert(attr)) {
-        return rid + attr.weight-1;
+    if (lfsr_rattr_isinsert(rattr)) {
+        return rid + rattr.weight-1;
     } else {
-        return rid + attr.weight;
+        return rid + rattr.weight;
     }
 }
 
-static inline lfs_size_t lfsr_attr_size(lfsr_attr_t attr) {
-    return lfsr_cat_size(attr.cat, attr.count);
+static inline lfs_size_t lfsr_rattr_size(lfsr_rattr_t rattr) {
+    return lfsr_cat_size(rattr.cat, rattr.count);
 }
 
-// special attrs - here be hacks
+// special rattrs - here be hacks
 
 // special case for passing names, we need to cat but we don't need the
 // full lfsr_data_t
@@ -2378,8 +2378,8 @@ typedef struct lfsr_data_name {
     const uint8_t *name;
 } lfsr_data_name_t;
 
-#define LFSR_ATTR_NAME(_tag, _weight, _did, _name, _name_size) \
-    LFSR_ATTR_CAT_( \
+#define LFSR_RATTR_NAME(_tag, _weight, _did, _name, _name_size) \
+    LFSR_RATTR_CAT_( \
         _tag, \
         _weight, \
         ((lfsr_data_t*)&(lfsr_data_name_t){ \
@@ -2388,48 +2388,48 @@ typedef struct lfsr_data_name {
             .name=(const void*)(_name)}), \
         2)
 
-// hacky attrs - these end up handled as special cases in high-level
+// hacky rattrs - these end up handled as special cases in high-level
 // commit layers
 
-// chain another attr-list, only allowed as last attr
-#define LFSR_ATTR_ATTRS(_tag, _weight, _attrs, _attr_count) \
-    LFSR_ATTR_(_tag, _weight, (const lfsr_attr_t*){_attrs}, _attr_count)
+// chain another rattr-list, only allowed as last rattr
+#define LFSR_RATTR_RATTRS(_tag, _weight, _rattrs, _rattr_count) \
+    LFSR_RATTR_(_tag, _weight, (const lfsr_rattr_t*){_rattrs}, _rattr_count)
 
 // chain a list of user attributes, these require a bit of last-minute
 // reencoding during commits
-#define LFSR_ATTR_UATTRS(_tag, _weight, _attrs, _attr_count) \
-    LFSR_ATTR_(_tag, _weight, (const struct lfs_attr*){_attrs}, _attr_count)
+#define LFSR_RATTR_ATTRS(_tag, _weight, _attrs, _attr_count) \
+    LFSR_RATTR_(_tag, _weight, (const struct lfs_attr*){_attrs}, _attr_count)
 
-// a move of all attrs from an mdir entry
-#define LFSR_ATTR_MOVE(_tag, _weight, _mdir) \
-    LFSR_ATTR_(_tag, _weight, (const lfsr_mdir_t*){_mdir}, 0)
+// a move of all rattrs from an mdir entry
+#define LFSR_RATTR_MOVE(_tag, _weight, _mdir) \
+    LFSR_RATTR_(_tag, _weight, (const lfsr_mdir_t*){_mdir}, 0)
 
 // a grm update, note this is mutable! we may update the grm during
 // mdir commits
-#define LFSR_ATTR_GRM(_tag, _weight, _grm) \
-    LFSR_ATTR_(_tag, _weight, (const lfsr_grm_t*){_grm}, 0)
+#define LFSR_RATTR_GRM(_tag, _weight, _grm) \
+    LFSR_RATTR_(_tag, _weight, (const lfsr_grm_t*){_grm}, 0)
 
 // writing to an unrelated trunk in the rbyd
 typedef struct lfsr_shrubcommit lfsr_shrubcommit_t;
-#define LFSR_ATTR_SHRUBCOMMIT(_tag, _weight, \
-        _shrub, _rid, _attrs, _attr_count) \
-    LFSR_ATTR_(_tag, _weight, \
+#define LFSR_RATTR_SHRUBCOMMIT(_tag, _weight, \
+        _shrub, _rid, _rattrs, _rattr_count) \
+    LFSR_RATTR_(_tag, _weight, \
         (&(const lfsr_shrubcommit_t){ \
             .shrub=_shrub, \
             .rid=_rid, \
-            .attrs=_attrs, \
-            .attr_count=_attr_count}), \
+            .rattrs=_rattrs, \
+            .rattr_count=_rattr_count}), \
         0)
 
-#define LFSR_ATTR_SHRUBTRUNK(_tag, _weight, _shrub) \
-    LFSR_ATTR_(_tag, _weight, (const lfsr_shrub_t*){_shrub}, 0)
+#define LFSR_RATTR_SHRUBTRUNK(_tag, _weight, _shrub) \
+    LFSR_RATTR_(_tag, _weight, (const lfsr_shrub_t*){_shrub}, 0)
 
 
 // operations on custom attribute lists
 //
 // a slightly different struct because it's user facing
 
-static inline lfs_ssize_t lfsr_uattr_size(const struct lfs_attr *attr) {
+static inline lfs_ssize_t lfsr_attr_size(const struct lfs_attr *attr) {
     // we default to the buffer_size if a mutable size is not provided
     if (attr->size) {
         return *attr->size;
@@ -2438,22 +2438,22 @@ static inline lfs_ssize_t lfsr_uattr_size(const struct lfs_attr *attr) {
     }
 }
 
-static inline bool lfsr_uattr_isnoattr(const struct lfs_attr *attr) {
-    return lfsr_uattr_size(attr) == LFS_ERR_NOATTR;
+static inline bool lfsr_attr_isnoattr(const struct lfs_attr *attr) {
+    return lfsr_attr_size(attr) == LFS_ERR_NOATTR;
 }
 
-static lfs_scmp_t lfsr_uattr_cmp(lfs_t *lfs, const struct lfs_attr *attr,
+static lfs_scmp_t lfsr_attr_cmp(lfs_t *lfs, const struct lfs_attr *attr,
         const lfsr_data_t *data) {
     // note data=NULL => NOATTR
     if (!data) {
-        return (lfsr_uattr_isnoattr(attr)) ? LFS_CMP_EQ : LFS_CMP_GT;
+        return (lfsr_attr_isnoattr(attr)) ? LFS_CMP_EQ : LFS_CMP_GT;
     } else {
-        if (lfsr_uattr_isnoattr(attr)) {
+        if (lfsr_attr_isnoattr(attr)) {
             return LFS_CMP_LT;
         } else {
             return lfsr_data_cmp(lfs, *data,
                     attr->buffer,
-                    lfsr_uattr_size(attr));
+                    lfsr_attr_size(attr));
         }
     }
 }
@@ -3746,15 +3746,15 @@ static int lfsr_rbyd_appendcat(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     return 0;
 }
 
-static int lfsr_rbyd_appendattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd,
-        lfsr_attr_t attr) {
+static int lfsr_rbyd_appendrattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd,
+        lfsr_rattr_t rattr) {
     int err = lfsr_rbyd_appendtag(lfs, rbyd,
-            attr.tag, attr.weight, lfsr_attr_size(attr));
+            rattr.tag, rattr.weight, lfsr_rattr_size(rattr));
     if (err) {
         return err;
     }
 
-    err = lfsr_rbyd_appendcat(lfs, rbyd, attr.cat, attr.count);
+    err = lfsr_rbyd_appendcat(lfs, rbyd, rattr.cat, rattr.count);
     if (err) {
         return err;
     }
@@ -3784,7 +3784,7 @@ static int lfsr_rbyd_appendinit(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
 }
 
 // helper functions for managing the 3-element fifo used in
-// lfsr_rbyd_appendattr
+// lfsr_rbyd_appendrattr
 typedef struct lfsr_alt {
     lfsr_tag_t alt;
     lfsr_rid_t weight;
@@ -3883,19 +3883,19 @@ static void lfsr_rbyd_p_recolor(
 }
 
 // core rbyd algorithm
-static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
-        lfsr_srid_t rid, lfsr_attr_t attr) {
+static int lfsr_rbyd_appendrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
+        lfsr_srid_t rid, lfsr_rattr_t rattr) {
     // must fetch before mutating!
     LFS_ASSERT(lfsr_rbyd_isfetched(rbyd));
     // tag must not be internal at this point
-    LFS_ASSERT(!lfsr_tag_isinternal(attr.tag));
+    LFS_ASSERT(!lfsr_tag_isinternal(rattr.tag));
     // bit 7 is reserved for future subtype extensions
-    LFS_ASSERT(!(attr.tag & 0x80));
+    LFS_ASSERT(!(rattr.tag & 0x80));
     // you can't delete more than what's in the rbyd
-    LFS_ASSERT(attr.weight >= -(lfsr_srid_t)rbyd->weight);
+    LFS_ASSERT(rattr.weight >= -(lfsr_srid_t)rbyd->weight);
 
     // ignore noops
-    if (lfsr_attr_isnoop(attr)) {
+    if (lfsr_rattr_isnoop(rattr)) {
         return 0;
     }
 
@@ -3910,8 +3910,8 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     lfsr_srid_t b_rid;
     lfsr_tag_t a_tag;
     lfsr_tag_t b_tag;
-    if (!lfsr_tag_isgrow(attr.tag) && attr.weight != 0) {
-        if (attr.weight > 0) {
+    if (!lfsr_tag_isgrow(rattr.tag) && rattr.weight != 0) {
+        if (rattr.weight > 0) {
             LFS_ASSERT(rid <= (lfsr_srid_t)rbyd->weight);
 
             // it's a bit ugly, but adjusting the rid here makes the following
@@ -3925,7 +3925,7 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
             // it's a bit ugly, but adjusting the rid here makes the following
             // logic work out more consistently
             rid += 1;
-            a_rid = rid - lfs_smax(-attr.weight, 0);
+            a_rid = rid - lfs_smax(-rattr.weight, 0);
             b_rid = rid;
         }
 
@@ -3935,23 +3935,23 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     } else {
         LFS_ASSERT(rid < (lfsr_srid_t)rbyd->weight);
 
-        a_rid = rid - lfs_smax(-attr.weight, 0);
+        a_rid = rid - lfs_smax(-rattr.weight, 0);
         b_rid = rid;
 
         // note both normal and rm wide-tags have the same bounds, really it's
         // the normal non-wide-tags that are an outlier here
-        if (lfsr_tag_issup(attr.tag)) {
+        if (lfsr_tag_issup(rattr.tag)) {
             a_tag = 0x000;
             b_tag = 0xf00;
-        } else if (lfsr_tag_issub(attr.tag)) {
-            a_tag = lfsr_tag_supkey(attr.tag);
-            b_tag = lfsr_tag_supkey(attr.tag) + 0x100;
-        } else if (lfsr_tag_isrm(attr.tag)) {
-            a_tag = lfsr_tag_key(attr.tag);
-            b_tag = lfsr_tag_key(attr.tag) + 1;
+        } else if (lfsr_tag_issub(rattr.tag)) {
+            a_tag = lfsr_tag_supkey(rattr.tag);
+            b_tag = lfsr_tag_supkey(rattr.tag) + 0x100;
+        } else if (lfsr_tag_isrm(rattr.tag)) {
+            a_tag = lfsr_tag_key(rattr.tag);
+            b_tag = lfsr_tag_key(rattr.tag) + 1;
         } else {
-            a_tag = lfsr_tag_key(attr.tag);
-            b_tag = lfsr_tag_key(attr.tag);
+            a_tag = lfsr_tag_key(rattr.tag);
+            b_tag = lfsr_tag_key(rattr.tag);
         }
     }
     a_tag = lfs_max(a_tag, 0x1);
@@ -4341,7 +4341,7 @@ trunk:;
                     }
 
                     // terminate diverged trunk with an unreachable tag
-                    err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR(
+                    err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR(
                             (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0)
                                 | LFSR_TAG_NULL,
                             0,
@@ -4388,20 +4388,20 @@ stem:;
     lfsr_tag_t alt = 0;
     lfsr_rid_t weight = 0;
     if (tag_
-            && (upper_rid-1 < rid-lfs_smax(-attr.weight, 0)
-                || (upper_rid-1 == rid-lfs_smax(-attr.weight, 0)
-                    && ((!lfsr_tag_isgrow(attr.tag) && attr.weight > 0)
-                        || (!lfsr_tag_issup(attr.tag)
+            && (upper_rid-1 < rid-lfs_smax(-rattr.weight, 0)
+                || (upper_rid-1 == rid-lfs_smax(-rattr.weight, 0)
+                    && ((!lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0)
+                        || (!lfsr_tag_issup(rattr.tag)
                             && lfsr_tag_supkey(tag_)
-                                < lfsr_tag_supkey(attr.tag))
-                        || (!lfsr_tag_issup(attr.tag)
-                            && !lfsr_tag_issub(attr.tag)
+                                < lfsr_tag_supkey(rattr.tag))
+                        || (!lfsr_tag_issup(rattr.tag)
+                            && !lfsr_tag_issub(rattr.tag)
                             && lfsr_tag_key(tag_)
-                                < lfsr_tag_key(attr.tag)))))) {
-        if (lfsr_tag_isrm(attr.tag) || !lfsr_tag_key(attr.tag)) {
+                                < lfsr_tag_key(rattr.tag)))))) {
+        if (lfsr_tag_isrm(rattr.tag) || !lfsr_tag_key(rattr.tag)) {
             // if removed, make our tag unreachable
             alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag);
-            weight = upper_rid - lower_rid + attr.weight;
+            weight = upper_rid - lower_rid + rattr.weight;
             upper_rid -= weight;
         } else {
             // split less than
@@ -4413,22 +4413,22 @@ stem:;
     } else if (tag_
             && (upper_rid-1 > rid
                 || (upper_rid-1 == rid
-                    && ((!lfsr_tag_isgrow(attr.tag) && attr.weight > 0)
-                        || (!lfsr_tag_issup(attr.tag)
+                    && ((!lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0)
+                        || (!lfsr_tag_issup(rattr.tag)
                             && lfsr_tag_supkey(tag_)
-                                > lfsr_tag_supkey(attr.tag))
-                        || (!lfsr_tag_issup(attr.tag)
-                            && !lfsr_tag_issub(attr.tag)
+                                > lfsr_tag_supkey(rattr.tag))
+                        || (!lfsr_tag_issup(rattr.tag)
+                            && !lfsr_tag_issub(rattr.tag)
                             && lfsr_tag_key(tag_)
-                                > lfsr_tag_key(attr.tag)))))) {
-        if (lfsr_tag_isrm(attr.tag) || !lfsr_tag_key(attr.tag)) {
+                                > lfsr_tag_key(rattr.tag)))))) {
+        if (lfsr_tag_isrm(rattr.tag) || !lfsr_tag_key(rattr.tag)) {
             // if removed, make our tag unreachable
             alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag);
-            weight = upper_rid - lower_rid + attr.weight;
+            weight = upper_rid - lower_rid + rattr.weight;
             upper_rid -= weight;
         } else {
             // split greater than
-            alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, attr.tag);
+            alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, rattr.tag);
             weight = upper_rid - (rid+1);
             upper_rid -= weight;
         }
@@ -4456,22 +4456,22 @@ leaf:;
     //
     // note we always need a non-alt to terminate the trunk, otherwise we
     // can't find trunks during fetch
-    err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR_(
+    err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_(
             // mark as shrub if we are a shrub
             (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0)
                 // rm => null, otherwise strip off control bits
-                | ((lfsr_tag_isrm(attr.tag))
+                | ((lfsr_tag_isrm(rattr.tag))
                     ? LFSR_TAG_NULL
-                    : lfsr_tag_key(attr.tag)),
-            upper_rid - lower_rid + attr.weight,
-            attr.cat, attr.count));
+                    : lfsr_tag_key(rattr.tag)),
+            upper_rid - lower_rid + rattr.weight,
+            rattr.cat, rattr.count));
     if (err) {
         return err;
     }
 
     // update the trunk and weight
     rbyd->trunk = (rbyd->trunk & LFSR_RBYD_ISSHRUB) | trunk_;
-    rbyd->weight += attr.weight;
+    rbyd->weight += rattr.weight;
     return 0;
 }
 
@@ -4542,7 +4542,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
         }
 
         uint8_t ecksum_buf[LFSR_ECKSUM_DSIZE];
-        err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR(
+        err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR(
                 LFSR_TAG_ECKSUM, 0, LFSR_DATA_ECKSUM_(
                     (&(lfsr_ecksum_t){
                         .cksize=lfs->cfg->prog_size,
@@ -4621,14 +4621,14 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
     return 0;
 }
 
-static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd,
+static int lfsr_rbyd_appendrattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd,
         lfsr_srid_t rid, lfsr_srid_t start_rid, lfsr_srid_t end_rid,
-        const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // append each tag to the tree
-    for (lfs_size_t i = 0; i < attr_count; i++) {
+    for (lfs_size_t i = 0; i < rattr_count; i++) {
         // treat inserts after the first tag as though they are splits,
         // sequential inserts don't really make sense otherwise
-        if (i > 0 && lfsr_attr_isinsert(attrs[i])) {
+        if (i > 0 && lfsr_rattr_isinsert(rattrs[i])) {
             rid += 1;
         }
 
@@ -4638,9 +4638,9 @@ static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd,
                 // treat end_rid=-1 as "unbounded" in such a way that rid=-1
                 // is still included
                 && (lfs_size_t)(rid + 1) <= (lfs_size_t)end_rid) {
-            int err = lfsr_rbyd_appendattr(lfs, rbyd,
+            int err = lfsr_rbyd_appendrattr(lfs, rbyd,
                     rid - lfs_smax(start_rid, 0),
-                    attrs[i]);
+                    rattrs[i]);
             if (err) {
                 return err;
             }
@@ -4649,24 +4649,24 @@ static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd,
         // we need to make sure we keep start_rid/end_rid updated with
         // weight changes
         if (rid < start_rid) {
-            start_rid += attrs[i].weight;
+            start_rid += rattrs[i].weight;
         }
         if (rid < end_rid) {
-            end_rid += attrs[i].weight;
+            end_rid += rattrs[i].weight;
         }
 
         // adjust rid
-        rid = lfsr_attr_nextrid(attrs[i], rid);
+        rid = lfsr_rattr_nextrid(rattrs[i], rid);
     }
 
     return 0;
 }
 
 static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd,
-        lfsr_srid_t rid, const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        lfsr_srid_t rid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // append each tag to the tree
-    int err = lfsr_rbyd_appendattrs(lfs, rbyd, rid, -1, -1,
-            attrs, attr_count);
+    int err = lfsr_rbyd_appendrattrs(lfs, rbyd, rid, -1, -1,
+            rattrs, rattr_count);
     if (err) {
         return err;
     }
@@ -4694,7 +4694,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
     // calculate dsize by starting from the outside ids and working inwards,
     // this naturally gives us a split rid
     //
-    // TODO adopt this a/b naming scheme in lfsr_rbyd_appendattr?
+    // TODO adopt this a/b naming scheme in lfsr_rbyd_appendrattr?
     lfsr_srid_t a_rid = start_rid;
     lfsr_srid_t b_rid = lfs_min(rbyd->weight, end_rid);
     lfs_size_t a_dsize = 0;
@@ -4738,7 +4738,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
             weight += weight_;
 
             // include the cost of this tag
-            dsize_ += lfs->attr_estimate + lfsr_data_size(data);
+            dsize_ += lfs->rattr_estimate + lfsr_data_size(data);
         }
 
         if (a_rid == -1) {
@@ -4764,9 +4764,9 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
 // appends a raw tag as a part of compaction, note these must
 // be appended in order!
 //
-// also note attr.weight here is total weight not delta weight
-static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
-        lfsr_attr_t attr) {
+// also note rattr.weight here is total weight not delta weight
+static int lfsr_rbyd_appendcompactrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
+        lfsr_rattr_t rattr) {
     // begin appending
     int err = lfsr_rbyd_appendinit(lfs, rbyd);
     if (err) {
@@ -4774,10 +4774,10 @@ static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     }
 
     // write the tag
-    err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR_(
-            (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | attr.tag,
-            attr.weight,
-            attr.cat, attr.count));
+    err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_(
+            (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | rattr.tag,
+            rattr.weight,
+            rattr.cat, rattr.count));
     if (err) {
         return err;
     }
@@ -4810,7 +4810,7 @@ static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
         }
 
         // write the tag
-        err = lfsr_rbyd_appendcompactattr(lfs, rbyd_, LFSR_ATTR_CAT_(
+        err = lfsr_rbyd_appendcompactrattr(lfs, rbyd_, LFSR_RATTR_CAT_(
                 tag, weight, &data, 1));
         if (err) {
             return err;
@@ -5487,7 +5487,7 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree,
 
 // extra state needed for non-terminating lfsr_btree_commit__ calls
 typedef struct lfsr_bscratch {
-    lfsr_attr_t attrs[4];
+    lfsr_rattr_t rattrs[4];
     lfsr_data_t split_data;
     uint8_t buf[2*LFSR_BRANCH_DSIZE];
 } lfsr_bscratch_t;
@@ -5501,11 +5501,11 @@ typedef struct lfsr_bscratch {
 static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
         lfsr_bscratch_t *bscratch,
         lfsr_bid_t *bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid,
-        const lfsr_attr_t **attrs, lfs_size_t *attr_count) {
+        const lfsr_rattr_t **rattrs, lfs_size_t *rattr_count) {
     lfsr_bid_t bid_ = *bid;
     LFS_ASSERT(bid_ <= (lfsr_bid_t)btree->weight);
-    const lfsr_attr_t *attrs_ = *attrs;
-    lfs_size_t attr_count_ = *attr_count;
+    const lfsr_rattr_t *rattrs_ = *rattrs;
+    lfs_size_t rattr_count_ = *rattr_count;
 
     // if rbyd is NULL, lookup which leaf our bid resides
     //
@@ -5548,8 +5548,8 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
             if (!lfsr_rbyd_trunk(&rbyd_)
                     || lfsr_rbyd_isshrub(btree)) {
                 *bid = rid_;
-                *attrs = attrs_;
-                *attr_count = attr_count_;
+                *rattrs = rattrs_;
+                *rattr_count = rattr_count_;
                 return (!lfsr_rbyd_trunk(&rbyd_)) ? LFS_ERR_RANGE : 0;
             }
 
@@ -5588,7 +5588,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
         // interacting with other references to the rbyd
         lfsr_rbyd_t rbyd__ = rbyd_;
         int err = lfsr_rbyd_commit(lfs, &rbyd__, rid_,
-                attrs_, attr_count_);
+                rattrs_, rattr_count_);
         if (err) {
             if (err == LFS_ERR_RANGE || err == LFS_ERR_CORRUPT) {
                 goto compact;
@@ -5743,10 +5743,10 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        // append any pending attrs, it's up to upper
+        // append any pending rattrs, it's up to upper
         // layers to make sure these always fit
         err = lfsr_rbyd_commit(lfs, &rbyd__, rid_,
-                attrs_, attr_count_);
+                rattrs_, rattr_count_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -5781,12 +5781,12 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        // append pending attrs < split_rid
+        // append pending rattrs < split_rid
         //
         // upper layers should make sure this can't fail by limiting the
         // maximum commit size
-        err = lfsr_rbyd_appendattrs(lfs, &rbyd__, rid_, -1, split_rid,
-                attrs_, attr_count_);
+        err = lfsr_rbyd_appendrattrs(lfs, &rbyd__, rid_, -1, split_rid,
+                rattrs_, rattr_count_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -5825,12 +5825,12 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        // append pending attrs >= split_rid
+        // append pending rattrs >= split_rid
         //
         // upper layers should make sure this can't fail by limiting the
         // maximum commit size
-        err = lfsr_rbyd_appendattrs(lfs, &sibling, rid_, split_rid, -1,
-                attrs_, attr_count_);
+        err = lfsr_rbyd_appendrattrs(lfs, &sibling, rid_, split_rid, -1,
+                rattrs_, rattr_count_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -5862,7 +5862,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
 
         // lookup first name in sibling to use as the split name
         //
-        // note we need to do this after playing out pending attrs in case
+        // note we need to do this after playing out pending rattrs in case
         // they introduce a new name!
         lfsr_tag_t split_tag;
         err = lfsr_rbyd_lookupnext(lfs, &sibling, 0, LFSR_TAG_NAME,
@@ -5875,49 +5875,49 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
         // prepare commit to parent, tail recursing upwards
         LFS_ASSERT(rbyd__.weight > 0);
         LFS_ASSERT(sibling.weight > 0);
-        attr_count_ = 0;
+        rattr_count_ = 0;
         // new root?
         if (!lfsr_rbyd_trunk(&parent)) {
-            bscratch->attrs[attr_count_++] = LFSR_ATTR(
+            bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                     LFSR_TAG_BRANCH, +rbyd__.weight,
                     LFSR_DATA_BRANCH_(
                         &rbyd__,
                         &bscratch->buf[0*LFSR_BRANCH_DSIZE]));
-            bscratch->attrs[attr_count_++] = LFSR_ATTR(
+            bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                     LFSR_TAG_BRANCH, +sibling.weight,
                     LFSR_DATA_BRANCH_(
                         &sibling,
                         &bscratch->buf[1*LFSR_BRANCH_DSIZE]));
             if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) {
-                bscratch->attrs[attr_count_++] = LFSR_ATTR_CAT_(
+                bscratch->rattrs[rattr_count_++] = LFSR_RATTR_CAT_(
                         LFSR_TAG_NAME, 0,
                         &bscratch->split_data, 1);
             }
         // split root?
         } else {
             bid_ -= pid - (rbyd_.weight-1);
-            bscratch->attrs[attr_count_++] = LFSR_ATTR(
+            bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                     LFSR_TAG_BRANCH, 0,
                     LFSR_DATA_BRANCH_(
                         &rbyd__,
                         &bscratch->buf[0*LFSR_BRANCH_DSIZE]));
             if (rbyd__.weight != rbyd_.weight) {
-                bscratch->attrs[attr_count_++] = LFSR_ATTR(
+                bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                         LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight,
                         LFSR_DATA_NULL());
             }
-            bscratch->attrs[attr_count_++] = LFSR_ATTR(
+            bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                     LFSR_TAG_BRANCH, +sibling.weight,
                     LFSR_DATA_BRANCH_(
                         &sibling,
                         &bscratch->buf[1*LFSR_BRANCH_DSIZE]));
             if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) {
-                bscratch->attrs[attr_count_++] = LFSR_ATTR_CAT_(
+                bscratch->rattrs[rattr_count_++] = LFSR_RATTR_CAT_(
                         LFSR_TAG_NAME, 0,
                         &bscratch->split_data, 1);
             }
         }
-        attrs_ = bscratch->attrs;
+        rattrs_ = bscratch->rattrs;
 
         rbyd_ = parent;
         rid_ = pid;
@@ -5962,10 +5962,10 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        // append any pending attrs, it's up to upper
+        // append any pending rattrs, it's up to upper
         // layers to make sure these always fit
         err = lfsr_rbyd_commit(lfs, &rbyd__, rid_,
-                attrs_, attr_count_);
+                rattrs_, rattr_count_);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -5981,25 +5981,25 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
         if (rbyd_.weight+sibling.weight == btree->weight) {
             // collapse the root, decreasing the height of the tree
             *btree = rbyd__;
-            *attr_count = 0;
+            *rattr_count = 0;
             return 0;
         }
 
         // prepare commit to parent, tail recursing upwards
         LFS_ASSERT(rbyd__.weight > 0);
-        attr_count_ = 0;
+        rattr_count_ = 0;
         bid_ -= pid - (rbyd_.weight-1);
-        bscratch->attrs[attr_count_++] = LFSR_ATTR(
+        bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                 LFSR_TAG_RM, -sibling.weight, LFSR_DATA_NULL());
-        bscratch->attrs[attr_count_++] = LFSR_ATTR(
+        bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                 LFSR_TAG_BRANCH, 0,
                 LFSR_DATA_BRANCH_(&rbyd__, bscratch->buf));
         if (rbyd__.weight != rbyd_.weight) {
-            bscratch->attrs[attr_count_++] = LFSR_ATTR(
+            bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                     LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight,
                     LFSR_DATA_NULL());
         }
-        attrs_ = bscratch->attrs;
+        rattrs_ = bscratch->rattrs;
 
         rbyd_ = parent;
         rid_ = pid + sibling.weight;
@@ -6009,7 +6009,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
         // done?
         if (!lfsr_rbyd_trunk(&parent)) {
             *btree = rbyd__;
-            *attr_count = 0;
+            *rattr_count = 0;
             return 0;
         }
 
@@ -6017,7 +6017,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
         if (rbyd_.weight == btree->weight) {
             // collapse the root, decreasing the height of the tree
             *btree = rbyd__;
-            *attr_count = 0;
+            *rattr_count = 0;
             return 0;
         }
 
@@ -6025,22 +6025,22 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
         //
         // note that since we defer merges to compaction time, we can
         // end up removing an rbyd here
-        attr_count_ = 0;
+        rattr_count_ = 0;
         bid_ -= pid - (rbyd_.weight-1);
         if (rbyd__.weight == 0) {
-            bscratch->attrs[attr_count_++] = LFSR_ATTR(
+            bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                     LFSR_TAG_RM, -rbyd_.weight, LFSR_DATA_NULL());
         } else {
-            bscratch->attrs[attr_count_++] = LFSR_ATTR(
+            bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                     LFSR_TAG_BRANCH, 0,
                     LFSR_DATA_BRANCH_(&rbyd__, bscratch->buf));
             if (rbyd__.weight != rbyd_.weight) {
-                bscratch->attrs[attr_count_++] = LFSR_ATTR(
+                bscratch->rattrs[rattr_count_++] = LFSR_RATTR(
                         LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight,
                         LFSR_DATA_NULL());
             }
         }
-        attrs_ = bscratch->attrs;
+        rattrs_ = bscratch->rattrs;
 
         rbyd_ = parent;
         rid_ = pid;
@@ -6051,18 +6051,18 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree,
 // commit to btree with optional rbyd
 static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         lfsr_bid_t bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid,
-        const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // try to commit to the btree
     lfsr_bscratch_t bscratch;
     int err = lfsr_btree_commit__(lfs, btree, &bscratch,
-            &bid, rbyd, rid, &attrs, &attr_count);
+            &bid, rbyd, rid, &rattrs, &rattr_count);
     if (err && err != LFS_ERR_RANGE) {
         return err;
     }
 
     // needs a new root?
     if (err == LFS_ERR_RANGE) {
-        LFS_ASSERT(attr_count > 0);
+        LFS_ASSERT(rattr_count > 0);
 
     relocate:;
         lfsr_rbyd_t rbyd_;
@@ -6071,7 +6071,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
             return err;
         }
 
-        err = lfsr_rbyd_commit(lfs, &rbyd_, bid, attrs, attr_count);
+        err = lfsr_rbyd_commit(lfs, &rbyd_, bid, rattrs, rattr_count);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             // bad prog? try another block
@@ -6090,9 +6090,9 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
 
 // commit to a btree, this is atomic
 static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree,
-        lfsr_bid_t bid, const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     return lfsr_btree_commit_(lfs, btree, bid, NULL, -1,
-            attrs, attr_count);
+            rattrs, rattr_count);
 }
 
 // lookup in a btree by name
@@ -6573,13 +6573,13 @@ static int lfsr_shrub_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
 struct lfsr_shrubcommit {
     lfsr_shrub_t *shrub;
     lfsr_srid_t rid;
-    const lfsr_attr_t *attrs;
-    lfs_size_t attr_count;
+    const lfsr_rattr_t *rattrs;
+    lfs_size_t rattr_count;
 };
 
 static int lfsr_shrub_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
         lfsr_shrub_t *shrub, lfsr_srid_t rid,
-        const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // swap out our trunk/weight temporarily, note we're
     // operating on a copy so if this fails we shouldn't mess
     // things up too much
@@ -6591,8 +6591,8 @@ static int lfsr_shrub_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
     rbyd_->weight = shrub->weight;
 
     // append any bshrub attributes
-    int err = lfsr_rbyd_appendattrs(lfs, rbyd_, rid, -1, -1,
-            attrs, attr_count);
+    int err = lfsr_rbyd_appendrattrs(lfs, rbyd_, rid, -1, -1,
+            rattrs, rattr_count);
     if (err) {
         return err;
     }
@@ -6830,13 +6830,13 @@ static int lfsr_bshrub_traverse(lfs_t *lfs,
 
 // needed in lfsr_bshrub_commit_
 static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
-        const lfsr_attr_t *attrs, lfs_size_t attr_count);
+        const lfsr_rattr_t *rattrs, lfs_size_t rattr_count);
 
 // commit to bshrub with optional rbyd
 static int lfsr_bshrub_commit_(lfs_t *lfs,
         lfsr_mdir_t *mdir, lfsr_bshrub_t *bshrub,
         lfsr_bid_t bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid,
-        const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // file must be a bshrub/btree here
     LFS_ASSERT(lfsr_bshrub_isbshruborbtree(bshrub));
 
@@ -6860,16 +6860,16 @@ static int lfsr_bshrub_commit_(lfs_t *lfs,
     // try to commit to the btree
     lfsr_bscratch_t bscratch;
     int err = lfsr_btree_commit__(lfs, &bshrub->u.btree, &bscratch,
-            &bid, rbyd, rid, &attrs, &attr_count);
+            &bid, rbyd, rid, &rattrs, &rattr_count);
     if (err && err != LFS_ERR_RANGE) {
         return err;
     }
-    LFS_ASSERT(!err || attr_count > 0);
+    LFS_ASSERT(!err || rattr_count > 0);
     bool alloc = (err == LFS_ERR_RANGE);
 
     // when btree is shrubbed, lfsr_btree_commit_ stops at the root
-    // and returns with pending attrs
-    if (attr_count > 0) {
+    // and returns with pending rattrs
+    if (rattr_count > 0) {
         // we need to prevent our shrub from overflowing our mdir somehow
         //
         // maintaining an accurate estimate is tricky and error-prone,
@@ -6882,13 +6882,13 @@ static int lfsr_bshrub_commit_(lfs_t *lfs,
 
         // figure out how much data this commit progs
         lfs_size_t commit_estimate = 0;
-        for (lfs_size_t i = 0; i < attr_count; i++) {
+        for (lfs_size_t i = 0; i < rattr_count; i++) {
             // only include tag overhead if tag is not a grow/rm tag
-            if (!lfsr_tag_isgrow(attrs[i].tag)
-                    && !lfsr_tag_isrm(attrs[i].tag)) {
-                commit_estimate += lfs->attr_estimate;
+            if (!lfsr_tag_isgrow(rattrs[i].tag)
+                    && !lfsr_tag_isrm(rattrs[i].tag)) {
+                commit_estimate += lfs->rattr_estimate;
             }
-            commit_estimate += lfsr_attr_size(attrs[i]);
+            commit_estimate += lfsr_rattr_size(rattrs[i]);
         }
 
         // does our estimate exceed our shrub_size? need to recalculate an
@@ -6922,10 +6922,10 @@ static int lfsr_bshrub_commit_(lfs_t *lfs,
         estimate += commit_estimate;
 
         // commit to shrub
-        int err = lfsr_mdir_commit(lfs, mdir, LFSR_ATTRS(
-                LFSR_ATTR_SHRUBCOMMIT(
+        int err = lfsr_mdir_commit(lfs, mdir, LFSR_RATTRS(
+                LFSR_RATTR_SHRUBCOMMIT(
                     LFSR_TAG_SHRUBCOMMIT, 0,
-                    &bshrub->u.bshrub, bid, attrs, attr_count)));
+                    &bshrub->u.bshrub, bid, rattrs, rattr_count)));
         if (err) {
             return err;
         }
@@ -6969,7 +6969,7 @@ relocate:;
         }
     }
 
-    err = lfsr_rbyd_commit(lfs, &rbyd_, bid, attrs, attr_count);
+    err = lfsr_rbyd_commit(lfs, &rbyd_, bid, rattrs, rattr_count);
     if (err) {
         LFS_ASSERT(err != LFS_ERR_RANGE);
         // bad prog? try another block
@@ -6986,11 +6986,11 @@ relocate:;
 // commit to a bshrub, this is atomic
 static int lfsr_bshrub_commit(lfs_t *lfs,
         lfsr_mdir_t *mdir, lfsr_bshrub_t *bshrub,
-        lfsr_bid_t bid, const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // file must be a bshrub/btree here
     LFS_ASSERT(lfsr_bshrub_isbshruborbtree(bshrub));
     return lfsr_bshrub_commit_(lfs, mdir, bshrub, bid, NULL, -1,
-            attrs, attr_count);
+            rattrs, rattr_count);
 }
 
 
@@ -7158,7 +7158,7 @@ static inline bool lfsr_o_iszombie(uint32_t flags) {
     return flags & LFS_O_ZOMBIE;
 }
 
-// custom attr flags
+// custom rattr flags
 static inline bool lfsr_a_islazy(uint32_t flags) {
     return flags & LFS_A_LAZY;
 }
@@ -7533,7 +7533,7 @@ static int lfsr_rbyd_appendgdelta(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
 
         // append to our rbyd, replacing any existing delta
         lfs_size_t size = lfsr_gdelta_size(grm_d, LFSR_GRM_DSIZE);
-        err = lfsr_rbyd_appendattr(lfs, rbyd, -1, LFSR_ATTR(
+        err = lfsr_rbyd_appendrattr(lfs, rbyd, -1, LFSR_RATTR(
                 // opportunistically remove this tag if delta is all zero
                 (size == 0)
                     ? LFSR_TAG_RM | LFSR_TAG_GRMDELTA
@@ -7983,9 +7983,9 @@ static int lfsr_mdir_swap__(lfs_t *lfs, lfsr_mdir_t *mdir_,
 // low-level mdir commit, does not handle mtree/mlist/compaction/etc
 static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
         lfsr_srid_t start_rid, lfsr_srid_t end_rid,
-        lfsr_smid_t mid, const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        lfsr_smid_t mid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // since we only ever commit to one mid or split, we can ignore the
-    // entire attr-list if our mid is out of range
+    // entire rattr-list if our mid is out of range
     lfsr_srid_t rid = lfsr_mid_rid(lfs, mid);
     if (rid >= start_rid
             // note the use of rid+1 and unsigned comparison here to
@@ -7993,29 +7993,29 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
             // is still included
             && (lfs_size_t)(rid + 1) <= (lfs_size_t)end_rid) {
 
-        for (lfs_size_t i = 0; i < attr_count; i++) {
+        for (lfs_size_t i = 0; i < rattr_count; i++) {
             // we just happen to never split in an mdir commit
-            LFS_ASSERT(!(i > 0 && lfsr_attr_isinsert(attrs[i])));
+            LFS_ASSERT(!(i > 0 && lfsr_rattr_isinsert(rattrs[i])));
 
-            // attr lists can be chained, but only tail-recursively
-            if (attrs[i].tag == LFSR_TAG_ATTRS) {
+            // rattr lists can be chained, but only tail-recursively
+            if (rattrs[i].tag == LFSR_TAG_RATTRS) {
                 // must be the last tag
-                LFS_ASSERT(i == attr_count-1);
+                LFS_ASSERT(i == rattr_count-1);
                 // how would weight make sense here?
-                LFS_ASSERT(attrs[i].weight == 0);
-                const lfsr_attr_t *attrs_ = attrs[i].cat;
-                lfs_size_t attr_count_ = attrs[i].count;
+                LFS_ASSERT(rattrs[i].weight == 0);
+                const lfsr_rattr_t *rattrs_ = rattrs[i].cat;
+                lfs_size_t rattr_count_ = rattrs[i].count;
 
-                // switch to chained attr-list
-                attrs = attrs_;
-                attr_count = attr_count_;
+                // switch to chained rattr-list
+                rattrs = rattrs_;
+                rattr_count = rattr_count_;
                 i = -1;
                 continue;
 
             // shrub tags append a set of attributes to an unrelated trunk
             // in our rbyd
-            } else if (attrs[i].tag == LFSR_TAG_SHRUBCOMMIT) {
-                const lfsr_shrubcommit_t *shrubcommit = attrs[i].cat;
+            } else if (rattrs[i].tag == LFSR_TAG_SHRUBCOMMIT) {
+                const lfsr_shrubcommit_t *shrubcommit = rattrs[i].cat;
                 // find the staging shrub
                 lfsr_shrub_t *shrub = shrubcommit->shrub;
                 lfsr_shrub_t *shrub_ = &((lfsr_bshrub_t*)shrub + 1)->u.bshrub;
@@ -8031,7 +8031,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                 // commit to shrub
                 int err = lfsr_shrub_commit(lfs, &mdir->rbyd,
                         shrub_, shrubcommit->rid,
-                        shrubcommit->attrs, shrubcommit->attr_count);
+                        shrubcommit->rattrs, shrubcommit->rattr_count);
                 if (err) {
                     return err;
                 }
@@ -8041,17 +8041,17 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
             //
             // TODO should we preserve mode for all of these?
             // TODO should we do the same for sprouts?
-            } else if (lfsr_tag_key(attrs[i].tag) == LFSR_TAG_SHRUBTRUNK) {
+            } else if (lfsr_tag_key(rattrs[i].tag) == LFSR_TAG_SHRUBTRUNK) {
                 // find the staging shrub
-                lfsr_shrub_t *shrub = (lfsr_shrub_t*)attrs[i].cat;
+                lfsr_shrub_t *shrub = (lfsr_shrub_t*)rattrs[i].cat;
                 lfsr_shrub_t *shrub_ = &((lfsr_bshrub_t*)shrub + 1)->u.bshrub;
 
                 uint8_t shrub_buf[LFSR_SHRUB_DSIZE];
-                int err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd,
+                int err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd,
                         rid - lfs_smax(start_rid, 0),
-                        LFSR_ATTR(
-                            lfsr_tag_mode(attrs[i].tag) | LFSR_TAG_BSHRUB,
-                            attrs[i].weight,
+                        LFSR_RATTR(
+                            lfsr_tag_mode(rattrs[i].tag) | LFSR_TAG_BSHRUB,
+                            rattrs[i].weight,
                             // note we use the staged trunk here
                             LFSR_DATA_SHRUB_(shrub_, shrub_buf)));
                 if (err) {
@@ -8061,10 +8061,10 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
             // move tags copy over any tags associated with the source's rid
             // TODO can this be deduplicated with lfsr_mdir_compact__ more?
             // it _really_ wants to be deduplicated
-            } else if (attrs[i].tag == LFSR_TAG_MOVE) {
+            } else if (rattrs[i].tag == LFSR_TAG_MOVE) {
                 // weighted moves are not supported
-                LFS_ASSERT(attrs[i].weight == 0);
-                const lfsr_mdir_t *mdir__ = attrs[i].cat;
+                LFS_ASSERT(rattrs[i].weight == 0);
+                const lfsr_mdir_t *mdir__ = rattrs[i].cat;
 
                 // skip the name tag, this is always replaced by upper layers
                 lfsr_tag_t tag = LFSR_TAG_STRUCT-1;
@@ -8082,9 +8082,9 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                     // found an inlined sprout? we can just copy this like
                     // normal but we need to update any opened inlined files
                     if (tag == LFSR_TAG_DATA) {
-                        err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd,
+                        err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd,
                                 rid - lfs_smax(start_rid, 0),
-                                LFSR_ATTR_CAT_(tag, 0, &data, 1));
+                                LFSR_RATTR_CAT_(tag, 0, &data, 1));
                         if (err) {
                             return err;
                         }
@@ -8114,20 +8114,20 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
 
                         // write our new shrub tag
                         uint8_t shrub_buf[LFSR_SHRUB_DSIZE];
-                        err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd,
+                        err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd,
                                 rid - lfs_smax(start_rid, 0),
-                                LFSR_ATTR(
+                                LFSR_RATTR(
                                     LFSR_TAG_BSHRUB, 0,
                                     LFSR_DATA_SHRUB_(&shrub, shrub_buf)));
                         if (err) {
                             return err;
                         }
 
-                    // append the attr
+                    // append the rattr
                     } else {
-                        err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd,
+                        err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd,
                                 rid - lfs_smax(start_rid, 0),
-                                LFSR_ATTR_CAT_(tag, 0, &data, 1));
+                                LFSR_RATTR_CAT_(tag, 0, &data, 1));
                         if (err) {
                             return err;
                         }
@@ -8150,8 +8150,8 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                             // the new block
                             && bshrub->bshrub_.u.bsprout.u.disk.block
                                 != mdir->rbyd.blocks[0]) {
-                        int err = lfsr_rbyd_appendcompactattr(lfs, &mdir->rbyd,
-                                LFSR_ATTR_CAT_(
+                        int err = lfsr_rbyd_appendcompactrattr(lfs, &mdir->rbyd,
+                                LFSR_RATTR_CAT_(
                                     LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0,
                                     &bshrub->bshrub.u.bsprout, 1));
                         if (err) {
@@ -8182,9 +8182,9 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                 }
 
             // custom attributes need to be reencoded into our tag format
-            } else if (lfsr_tag_key(attrs[i].tag) == LFSR_TAG_UATTRS) {
-                const struct lfs_attr *attrs_ = attrs[i].cat;
-                lfs_size_t attr_count_ = attrs[i].count;
+            } else if (lfsr_tag_key(rattrs[i].tag) == LFSR_TAG_ATTRS) {
+                const struct lfs_attr *attrs_ = rattrs[i].cat;
+                lfs_size_t attr_count_ = rattrs[i].count;
 
                 for (lfs_size_t j = 0; j < attr_count_; j++) {
                     // skip readonly attrs and lazy attrs
@@ -8203,7 +8203,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                     }
 
                     // does disk match our attr?
-                    lfs_scmp_t cmp = lfsr_uattr_cmp(lfs, &attrs_[j],
+                    lfs_scmp_t cmp = lfsr_attr_cmp(lfs, &attrs_[j],
                             (err != LFS_ERR_NOENT) ? &data : NULL);
                     if (cmp < 0) {
                         return cmp;
@@ -8214,19 +8214,19 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                     }
 
                     // append the custom attr
-                    err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd,
+                    err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd,
                             rid - lfs_smax(start_rid, 0),
                             // removing or updating?
-                            (lfsr_uattr_isnoattr(&attrs_[j]))
-                                ? LFSR_ATTR(
+                            (lfsr_attr_isnoattr(&attrs_[j]))
+                                ? LFSR_RATTR(
                                     LFSR_TAG_RM
                                         | LFSR_TAG_ATTR(attrs_[j].type), 0,
                                     LFSR_DATA_NULL())
-                                : LFSR_ATTR(
+                                : LFSR_RATTR(
                                     LFSR_TAG_ATTR(attrs_[j].type), 0,
                                     LFSR_DATA_BUF(
                                         attrs_[j].buffer,
-                                        lfsr_uattr_size(&attrs_[j]))));
+                                        lfsr_attr_size(&attrs_[j]))));
                     if (err) {
                         return err;
                     }
@@ -8234,18 +8234,18 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
 
             // write out normal tags normally
             } else {
-                LFS_ASSERT(!lfsr_tag_isinternal(attrs[i].tag));
+                LFS_ASSERT(!lfsr_tag_isinternal(rattrs[i].tag));
 
-                int err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd,
+                int err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd,
                         rid - lfs_smax(start_rid, 0),
-                        attrs[i]);
+                        rattrs[i]);
                 if (err) {
                     return err;
                 }
             }
 
             // adjust rid
-            rid = lfsr_attr_nextrid(attrs[i], rid);
+            rid = lfsr_rattr_nextrid(rattrs[i], rid);
         }
     }
 
@@ -8338,7 +8338,7 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir,
                 if (dsize__ < 0) {
                     return dsize__;
                 }
-                dsize_ += lfs->attr_estimate + dsize__;
+                dsize_ += lfs->rattr_estimate + dsize__;
 
             // special handling for shrub trunks, we need to include the
             // compacted cost of the shrub in our estimate
@@ -8360,11 +8360,11 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir,
                 if (dsize__ < 0) {
                     return dsize__;
                 }
-                dsize_ += lfs->attr_estimate + dsize__;
+                dsize_ += lfs->rattr_estimate + dsize__;
 
             } else {
                 // include the cost of this tag
-                dsize_ += lfs->attr_estimate + lfsr_data_size(data);
+                dsize_ += lfs->rattr_estimate + lfsr_data_size(data);
             }
         }
 
@@ -8460,8 +8460,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
         // found an inlined sprout? we can just copy this like normal but
         // we need to update any opened inlined files
         if (tag == LFSR_TAG_DATA) {
-            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
-                    LFSR_ATTR_CAT_(tag, weight, &data, 1));
+            err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd,
+                    LFSR_RATTR_CAT_(tag, weight, &data, 1));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
@@ -8494,8 +8494,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
 
             // write the new shrub tag
             uint8_t shrub_buf[LFSR_SHRUB_DSIZE];
-            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
-                    LFSR_ATTR(
+            err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd,
+                    LFSR_RATTR(
                         tag, weight,
                         LFSR_DATA_SHRUB_(&shrub, shrub_buf)));
             if (err) {
@@ -8505,8 +8505,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
 
         } else {
             // write the tag
-            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
-                    LFSR_ATTR_CAT_(tag, weight, &data, 1));
+            err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd,
+                    LFSR_RATTR_CAT_(tag, weight, &data, 1));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
@@ -8537,8 +8537,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
                 // only compact once, first compact should stage the new block
                 && bshrub->bshrub_.u.bsprout.u.disk.block
                     != mdir_->rbyd.blocks[0]) {
-            err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
-                    LFSR_ATTR_CAT_(
+            err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd,
+                    LFSR_RATTR_CAT_(
                         LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0,
                         &bshrub->bshrub.u.bsprout, 1));
             if (err) {
@@ -8574,7 +8574,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
 static int lfsr_mdir_commit_(lfs_t *lfs, lfsr_mdir_t *mdir,
         lfsr_srid_t start_rid, lfsr_srid_t end_rid,
         lfsr_srid_t *split_rid_,
-        lfsr_smid_t mid, const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        lfsr_smid_t mid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // make a copy
     lfsr_mdir_t mdir_ = *mdir;
     // mark as erased in case of failure
@@ -8582,7 +8582,7 @@ static int lfsr_mdir_commit_(lfs_t *lfs, lfsr_mdir_t *mdir,
 
     // try to commit
     int err = lfsr_mdir_commit__(lfs, &mdir_, start_rid, end_rid,
-            mid, attrs, attr_count);
+            mid, rattrs, rattr_count);
     if (err) {
         if (err == LFS_ERR_RANGE || err == LFS_ERR_CORRUPT) {
             goto swap;
@@ -8669,7 +8669,7 @@ compact:;
     // upper layers should make sure this can't fail by limiting the
     // maximum commit size
     err = lfsr_mdir_commit__(lfs, &mdir_, start_rid, end_rid,
-            mid, attrs, attr_count);
+            mid, rattrs, rattr_count);
     if (err) {
         LFS_ASSERT(err != LFS_ERR_RANGE);
         // bad prog? try another block
@@ -8732,7 +8732,7 @@ static int lfsr_mroot_parent(lfs_t *lfs, const lfs_block_t mptr[static 2],
 // state
 //
 static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
-        const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // non-mroot mdirs must have weight
     LFS_ASSERT(mdir->mid == -1
             // note inlined mdirs are mroots with mid != -1
@@ -8744,12 +8744,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
     // lfs->mroot must have mid=-1
     LFS_ASSERT(lfs->mroot.mid == -1);
 
-    // play out any attrs that affect our grm _before_ committing to disk,
+    // play out any rattrs that affect our grm _before_ committing to disk,
     // keep in mind we revert to on-disk gstate if we run into an error
     lfsr_smid_t mid_ = mdir->mid;
-    for (lfs_size_t i = 0; i < attr_count; i++) {
+    for (lfs_size_t i = 0; i < rattr_count; i++) {
         // automatically create grms for new bookmarks
-        if (attrs[i].tag == LFSR_TAG_BOOKMARK) {
+        if (rattrs[i].tag == LFSR_TAG_BOOKMARK) {
             lfsr_grm_push(lfs, mid_);
 
         // adjust pending grms?
@@ -8759,16 +8759,16 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                             == lfsr_mid_bid(lfs, mid_)
                         && lfs->grm.mids[j] >= mid_) {
                     // deleting a pending grm doesn't really make sense
-                    LFS_ASSERT(lfs->grm.mids[j] >= mid_ - attrs[i].weight);
+                    LFS_ASSERT(lfs->grm.mids[j] >= mid_ - rattrs[i].weight);
 
                     // adjust the grm
-                    lfs->grm.mids[j] += attrs[i].weight;
+                    lfs->grm.mids[j] += rattrs[i].weight;
                 }
             }
         }
 
         // adjust mid
-        mid_ = lfsr_attr_nextrid(attrs[i], mid_);
+        mid_ = lfsr_rattr_nextrid(rattrs[i], mid_);
     }
 
     // setup any pending gdeltas
@@ -8797,7 +8797,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
     // attempt to commit/compact the mdir normally
     lfsr_srid_t split_rid;
     int err = lfsr_mdir_commit_(lfs, &mdir_[0], -1, -1, &split_rid,
-            mdir->mid, attrs, attr_count);
+            mdir->mid, rattrs, rattr_count);
     if (err && err != LFS_ERR_RANGE
             && err != LFS_ERR_NOENT) {
         goto failed;
@@ -8862,7 +8862,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
             err = lfsr_mdir_commit__(lfs, &mdir_[i^left],
                     ((i^left) == 0) ?         0 : split_rid,
                     ((i^left) == 0) ? split_rid :        -1,
-                    mdir->mid, attrs, attr_count);
+                    mdir->mid, rattrs, rattr_count);
             if (err && err != LFS_ERR_NOENT) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 // bad prog? try another block
@@ -8877,7 +8877,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
             }
         }
 
-        // adjust our sibling's mid after committing attrs
+        // adjust our sibling's mid after committing rattrs
         mdir_[1].mid += (1 << lfs->mdir_bits);
 
         LFS_DEBUG("Splitting mdir %"PRId32" "
@@ -8927,7 +8927,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
 
         // lookup first name in sibling to use as the split name
         //
-        // note we need to do this after playing out pending attrs in
+        // note we need to do this after playing out pending rattrs in
         // case they introduce a new name!
         lfsr_data_t split_data;
         err = lfsr_rbyd_sublookup(lfs, &mdir_[1].rbyd, 0, LFSR_TAG_NAME,
@@ -8943,16 +8943,16 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
 
             uint8_t mdir_buf[2*LFSR_MPTR_DSIZE];
             err = lfsr_btree_commit(lfs, &mtree_.u.btree,
-                    0, LFSR_ATTRS(
-                        LFSR_ATTR(
+                    0, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_MDIR, +(1 << lfs->mdir_bits),
                             LFSR_DATA_MPTR_(
                                 mdir_[0].rbyd.blocks,
                                 &mdir_buf[0*LFSR_MPTR_DSIZE])),
-                        LFSR_ATTR_CAT_(
+                        LFSR_RATTR_CAT_(
                             LFSR_TAG_NAME, +(1 << lfs->mdir_bits),
                             &split_data, 1),
-                        LFSR_ATTR(
+                        LFSR_RATTR(
                             LFSR_TAG_MDIR, 0,
                             LFSR_DATA_MPTR_(
                                 mdir_[1].rbyd.blocks,
@@ -8968,16 +8968,16 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
 
             uint8_t mdir_buf[2*LFSR_MPTR_DSIZE];
             err = lfsr_btree_commit(lfs, &mtree_.u.btree,
-                    lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS(
-                        LFSR_ATTR(
+                    lfsr_mid_bid(lfs, mdir->mid), LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_MDIR, 0,
                             LFSR_DATA_MPTR_(
                                 mdir_[0].rbyd.blocks,
                                 &mdir_buf[0*LFSR_MPTR_DSIZE])),
-                        LFSR_ATTR_CAT_(
+                        LFSR_RATTR_CAT_(
                             LFSR_TAG_NAME, +(1 << lfs->mdir_bits),
                             &split_data, 1),
-                        LFSR_ATTR(
+                        LFSR_RATTR(
                             LFSR_TAG_MDIR, 0,
                             LFSR_DATA_MPTR_(
                                 mdir_[1].rbyd.blocks,
@@ -9014,8 +9014,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
 
         // update our mtree
         err = lfsr_btree_commit(lfs, &mtree_.u.btree,
-                lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS(
-                    LFSR_ATTR(
+                lfsr_mid_bid(lfs, mdir->mid), LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM, -(1 << lfs->mdir_bits),
                         LFSR_DATA_NULL())));
         if (err) {
@@ -9046,8 +9046,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
             // update our mtree
             uint8_t mdir_buf[LFSR_MPTR_DSIZE];
             err = lfsr_btree_commit(lfs, &mtree_.u.btree,
-                    lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS(
-                        LFSR_ATTR(
+                    lfsr_mid_bid(lfs, mdir->mid), LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_MDIR, 0,
                             LFSR_DATA_MPTR_(
                                 mdir_[0].rbyd.blocks,
@@ -9116,20 +9116,20 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
         // in our mroot
         uint8_t mtree_buf[LFS_MAX(LFSR_MPTR_DSIZE, LFSR_BTREE_DSIZE)];
         err = lfsr_mdir_commit_(lfs, &mroot_, -1, 0, NULL,
-                -1, LFSR_ATTRS(
+                -1, LFSR_RATTRS(
                     (lfsr_mtree_ismptr(&mtree_))
-                        ? LFSR_ATTR(
+                        ? LFSR_RATTR(
                             LFSR_TAG_SUB | LFSR_TAG_MDIR, 0,
                             LFSR_DATA_MPTR_(mtree_.u.mptr.blocks, mtree_buf))
-                        : LFSR_ATTR(
+                        : LFSR_RATTR(
                             LFSR_TAG_SUB | LFSR_TAG_MTREE, 0,
                             LFSR_DATA_BTREE_(&mtree_.u.btree, mtree_buf)),
-                    // were we committing to the mroot? include any -1 attrs
+                    // were we committing to the mroot? include any -1 rattrs
                     (mdir->mid == -1)
-                        ? LFSR_ATTR_ATTRS(
-                            LFSR_TAG_ATTRS, 0,
-                            attrs, attr_count)
-                        : LFSR_ATTR_NOOP()));
+                        ? LFSR_RATTR_RATTRS(
+                            LFSR_TAG_RATTRS, 0,
+                            rattrs, rattr_count)
+                        : LFSR_RATTR_NOOP()));
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             goto failed;
@@ -9169,8 +9169,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
             // commit mrootchild
             uint8_t mrootchild_buf[LFSR_MPTR_DSIZE];
             err = lfsr_mdir_commit_(lfs, &mrootparent_, -1, -1, NULL,
-                    -1, LFSR_ATTRS(
-                        LFSR_ATTR(
+                    -1, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_MROOT, 0,
                             LFSR_DATA_MPTR_(
                                 mrootchild_.rbyd.blocks,
@@ -9218,11 +9218,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
 
             uint8_t mrootchild_buf[LFSR_MPTR_DSIZE];
             err = lfsr_mdir_commit__(lfs, &mrootanchor_, -1, -1,
-                    -1, LFSR_ATTRS(
-                        LFSR_ATTR(
+                    -1, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_MAGIC, 0,
                             LFSR_DATA_BUF("littlefs", 8)),
-                        LFSR_ATTR(
+                        LFSR_RATTR(
                             LFSR_TAG_MROOT, 0,
                             LFSR_DATA_MPTR_(
                                 mrootchild_.rbyd.blocks,
@@ -9270,28 +9270,28 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
     // update any gstate changes
     lfsr_fs_commitgdelta(lfs);
 
-    // play out any attrs that affect internal state
+    // play out any rattrs that affect internal state
     mid_ = mdir->mid;
-    for (lfs_size_t i = 0; i < attr_count; i++) {
+    for (lfs_size_t i = 0; i < rattr_count; i++) {
         // adjust any opened mdirs
         for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) {
             // adjust opened mdirs?
             if (lfsr_mdir_cmp(&o->mdir, mdir) == 0
                     && o->mdir.mid >= mid_) {
                 // removed?
-                if (o->mdir.mid < mid_ - attrs[i].weight) {
+                if (o->mdir.mid < mid_ - rattrs[i].weight) {
                     // we should not be removing opened regular files
                     LFS_ASSERT(lfsr_o_type(o->flags) != LFS_TYPE_REG);
                     o->flags |= LFS_O_ZOMBIE;
                     o->mdir.mid = mid_;
                 } else {
-                    o->mdir.mid += attrs[i].weight;
+                    o->mdir.mid += rattrs[i].weight;
                 }
             }
         }
 
         // adjust mid
-        mid_ = lfsr_attr_nextrid(attrs[i], mid_);
+        mid_ = lfsr_rattr_nextrid(rattrs[i], mid_);
     }
 
     // update any staged bsprouts/bshrubs
@@ -10401,7 +10401,7 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) {
     //
     // Worst case (or best case?) each directory needs 1 name tag, 1 did
     // tag, and 1 bookmark. With our current compaction strategy, each tag
-    // needs 3t+4 bytes for tag+alts (see our attr_estimate). And, if
+    // needs 3t+4 bytes for tag+alts (see our rattr_estimate). And, if
     // we assume ~1/2 block utilization due to our mdir split threshold, we
     // can multiply everything by 2:
     //
@@ -10463,8 +10463,8 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) {
 
     // commit our bookmark and a grm to self-remove in case of powerloss
     lfs_alloc_ckpoint(lfs);
-    err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_BOOKMARK, +1, LFSR_DATA_LEB128(did_))));
+    err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_BOOKMARK, +1, LFSR_DATA_LEB128(did_))));
     if (err) {
         return err;
     }
@@ -10483,11 +10483,11 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) {
     // process
     lfsr_grm_pop(lfs);
     lfs_alloc_ckpoint(lfs);
-    err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_SUP | LFSR_TAG_DIR, (!exists) ? +1 : 0,
                 did, name, name_size),
-            LFSR_ATTR(LFSR_TAG_DID, 0, LFSR_DATA_LEB128(did_))));
+            LFSR_RATTR(LFSR_TAG_DID, 0, LFSR_DATA_LEB128(did_))));
     if (err) {
         return err;
     }
@@ -10621,16 +10621,16 @@ int lfsr_remove(lfs_t *lfs, const char *path) {
 
     // remove the metadata entry
     lfs_alloc_ckpoint(lfs);
-    err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
+    err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS(
             // create an orphan if zombied
             //
-            // we use a create+delete here to also clear any attrs
+            // we use a create+delete here to also clear any rattrs
             // and trim the entry size
             (zombie)
-                ? LFSR_ATTR_NAME(
+                ? LFSR_RATTR_NAME(
                     LFSR_TAG_SUP | LFSR_TAG_ORPHAN, 0,
                     did, name, name_size)
-                : LFSR_ATTR(
+                : LFSR_RATTR(
                     LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
     if (err) {
         return err;
@@ -10777,11 +10777,11 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) {
     // rename our entry, copying all tags associated with the old rid to the
     // new rid, while also marking the old rid for removal
     lfs_alloc_ckpoint(lfs);
-    err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_SUP | old_tag, (!exists) ? +1 : 0,
                 new_did, new_name, new_name_size),
-            LFSR_ATTR_MOVE(LFSR_TAG_MOVE, 0, &old_mdir)));
+            LFSR_RATTR_MOVE(LFSR_TAG_MOVE, 0, &old_mdir)));
     if (err) {
         return err;
     }
@@ -11228,8 +11228,8 @@ int lfsr_setattr(lfs_t *lfs, const char *path, uint8_t type,
 
     // commit our attr
     lfs_alloc_ckpoint(lfs);
-    err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(
+    err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(type), 0,
                 LFSR_DATA_BUF(buffer, size))));
     if (err) {
@@ -11280,8 +11280,8 @@ int lfsr_removeattr(lfs_t *lfs, const char *path, uint8_t type) {
 
     // commit our removal
     lfs_alloc_ckpoint(lfs);
-    err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(
+    err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(type), 0,
                 LFSR_DATA_NULL())));
     if (err) {
@@ -11560,8 +11560,8 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file,
         // mid until first sync
         if (!err) {
             lfs_alloc_ckpoint(lfs);
-            err = lfsr_mdir_commit(lfs, &file->o.o.mdir, LFSR_ATTRS(
-                    LFSR_ATTR_NAME(
+            err = lfsr_mdir_commit(lfs, &file->o.o.mdir, LFSR_RATTRS(
+                    LFSR_RATTR_NAME(
                         LFSR_TAG_ORPHAN, +1,
                         did, name, name_size)));
             if (err) {
@@ -11873,16 +11873,16 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file,
 // low-level file writing
 
 static int lfsr_file_commit(lfs_t *lfs, lfsr_file_t *file,
-        lfs_off_t pos, const lfsr_attr_t *attrs, lfs_size_t attr_count) {
+        lfs_off_t pos, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) {
     // file must be a bshrub/btree here
     LFS_ASSERT(lfsr_bshrub_isbshruborbtree(&file->o.bshrub));
     return lfsr_bshrub_commit(lfs,
             &file->o.o.mdir, &file->o.bshrub,
-            pos, attrs, attr_count);
+            pos, rattrs, rattr_count);
 }
 
 static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
-        lfs_off_t pos, lfs_off_t weight, lfsr_attr_t attr) {
+        lfs_off_t pos, lfs_off_t weight, lfsr_rattr_t rattr) {
     // Note! This function has some rather special constraints:
     //
     // 1. We must never allow our btree size to overflow, even temporarily.
@@ -11900,8 +11900,8 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
 
     // try to merge commits where possible
     lfsr_bid_t bid = lfsr_bshrub_size(&file->o.bshrub);
-    lfsr_attr_t attrs[5];
-    lfs_size_t attr_count = 0;
+    lfsr_rattr_t rattrs[5];
+    lfs_size_t rattr_count = 0;
     union {
         lfsr_data_t data;
         uint8_t buf[LFSR_BPTR_DSIZE];
@@ -11917,11 +11917,11 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         // but note that's already a risk with how file carve deletes
         // data before insertion
         if (lfsr_bshrub_isbsprout(&file->o.o.mdir, &file->o.bshrub)) {
-            attrs[attr_count++] = LFSR_ATTR_CAT_(
+            rattrs[rattr_count++] = LFSR_RATTR_CAT_(
                     LFSR_TAG_DATA, +lfsr_bshrub_size(&file->o.bshrub),
                     &file->o.bshrub.u.bsprout, 1);
         } else if (lfsr_bshrub_isbptr(&file->o.o.mdir, &file->o.bshrub)) {
-            attrs[attr_count++] = LFSR_ATTR(
+            rattrs[rattr_count++] = LFSR_RATTR(
                     LFSR_TAG_BLOCK, +lfsr_bshrub_size(&file->o.bshrub),
                     LFSR_DATA_BPTR_(&file->o.bshrub.u.bptr, left.buf));
         }
@@ -11929,17 +11929,17 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         file->o.bshrub.u.bshrub = LFSR_SHRUB_NULL(
                 file->o.o.mdir.rbyd.blocks[0]);
 
-        if (attr_count > 0) {
-            LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t));
+        if (rattr_count > 0) {
+            LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t));
 
             int err = lfsr_file_commit(lfs, file, 0,
-                    attrs, attr_count);
+                    rattrs, rattr_count);
             if (err) {
                 return err;
             }
         }
 
-        attr_count = 0;
+        rattr_count = 0;
     }
 
     // need a hole?
@@ -11947,21 +11947,21 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         // can we coalesce?
         if (lfsr_bshrub_size(&file->o.bshrub) > 0) {
             bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub)-1);
-            attrs[attr_count++] = LFSR_ATTR(
+            rattrs[rattr_count++] = LFSR_RATTR(
                     LFSR_TAG_GROW, +(pos - lfsr_bshrub_size(&file->o.bshrub)),
                     LFSR_DATA_NULL());
 
         // new hole
         } else {
             bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub));
-            attrs[attr_count++] = LFSR_ATTR(
+            rattrs[rattr_count++] = LFSR_RATTR(
                     LFSR_TAG_DATA, +(pos - lfsr_bshrub_size(&file->o.bshrub)),
                     LFSR_DATA_NULL());
         }
     }
 
     // try to carve any existing data
-    lfsr_attr_t right_attr_ = {.tag=0};
+    lfsr_rattr_t right_rattr_ = {.tag=0};
     while (pos < lfsr_bshrub_size(&file->o.bshrub)) {
         lfsr_tag_t tag_;
         lfsr_bid_t weight_;
@@ -12001,13 +12001,13 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
                     lfs->cfg->fragment_size,
                     -1);
             
-            err = lfsr_file_commit(lfs, file, bid, LFSR_ATTRS(
-                    LFSR_ATTR_CAT(
+            err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS(
+                    LFSR_RATTR_CAT(
                         LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA,
                             -(weight_ - lfs->cfg->fragment_size),
                         lfsr_data_truncate(left_slice_,
                                 lfs->cfg->fragment_size)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_BLOCK,
                             +(weight_ - lfs->cfg->fragment_size),
                         LFSR_DATA_BPTR_(&bptr_, left.buf))));
@@ -12030,12 +12030,12 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
                     -1,
                     lfsr_data_size(bptr_.data) - lfs->cfg->fragment_size);
 
-            err = lfsr_file_commit(lfs, file, bid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK,
                             -(weight_ - lfsr_data_size(bptr_.data)),
                         LFSR_DATA_BPTR_(&bptr_, right.buf)),
-                    LFSR_ATTR_CAT(
+                    LFSR_RATTR_CAT(
                         LFSR_TAG_DATA,
                             +(weight_ - lfsr_data_size(bptr_.data)),
                         lfsr_data_fruncate(right_slice_,
@@ -12055,20 +12055,20 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         if (bid-(weight_-1) < pos) {
             // can we get away with a grow attribute?
             if (lfsr_data_size(bptr_.data) == lfsr_data_size(left_slice_)) {
-                attrs[attr_count++] = LFSR_ATTR(
+                rattrs[rattr_count++] = LFSR_RATTR(
                         LFSR_TAG_GROW, -(bid+1 - pos), LFSR_DATA_NULL());
 
             // carve fragment?
             } else if (tag_ == LFSR_TAG_DATA) {
                 left.data = left_slice_;
-                attrs[attr_count++] = LFSR_ATTR_CAT_(
+                rattrs[rattr_count++] = LFSR_RATTR_CAT_(
                         LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA,
                             -(bid+1 - pos),
                         &left.data, 1);
 
             // carve bptr?
             } else if (tag_ == LFSR_TAG_BLOCK) {
-                attrs[attr_count++] = LFSR_ATTR(
+                rattrs[rattr_count++] = LFSR_RATTR(
                         LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK,
                             -(bid+1 - pos),
                         LFSR_DATA_BPTR_(
@@ -12090,7 +12090,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
 
         // completely overwriting this entry?
         } else {
-            attrs[attr_count++] = LFSR_ATTR(
+            rattrs[rattr_count++] = LFSR_RATTR(
                     LFSR_TAG_RM, -weight_, LFSR_DATA_NULL());
         }
 
@@ -12098,17 +12098,17 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         // so commit what we have and move on to next entry
         if (pos+weight > bid+1) {
             LFS_ASSERT(lfsr_data_size(right_slice_) == 0);
-            LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t));
+            LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t));
 
             err = lfsr_file_commit(lfs, file, bid,
-                    attrs, attr_count);
+                    rattrs, rattr_count);
             if (err) {
                 return err;
             }
 
-            attr.weight += lfs_min(weight, bid+1 - pos);
+            rattr.weight += lfs_min(weight, bid+1 - pos);
             weight -= lfs_min(weight, bid+1 - pos);
-            attr_count = 0;
+            rattr_count = 0;
             continue;
         }
 
@@ -12116,19 +12116,19 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         if (pos+weight < bid+1) {
             // can we coalesce a hole?
             if (lfsr_data_size(right_slice_) == 0) {
-                attr.weight += bid+1 - (pos+weight);
+                rattr.weight += bid+1 - (pos+weight);
 
             // carve fragment?
             } else if (tag_ == LFSR_TAG_DATA) {
                 right.data = right_slice_;
-                right_attr_ = LFSR_ATTR_CAT_(
+                right_rattr_ = LFSR_RATTR_CAT_(
                         tag_,
                         bid+1 - (pos+weight),
                         &right.data, 1);
 
             // carve bptr?
             } else if (tag_ == LFSR_TAG_BLOCK) {
-                right_attr_ = LFSR_ATTR(
+                right_rattr_ = LFSR_RATTR(
                         tag_,
                         bid+1 - (pos+weight),
                         LFSR_DATA_BPTR_(
@@ -12149,47 +12149,47 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
             }
         }
 
-        attr.weight += lfs_min(weight, bid+1 - pos);
+        rattr.weight += lfs_min(weight, bid+1 - pos);
         weight -= lfs_min(weight, bid+1 - pos);
         break;
     }
 
     // append our data
-    if (weight + attr.weight > 0) {
+    if (weight + rattr.weight > 0) {
         // can we coalesce a hole?
-        if (lfsr_attr_size(attr) == 0 && pos > 0) {
+        if (lfsr_rattr_size(rattr) == 0 && pos > 0) {
             bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub)-1);
-            attrs[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_GROW, +(weight + attr.weight),
+            rattrs[rattr_count++] = LFSR_RATTR(
+                    LFSR_TAG_GROW, +(weight + rattr.weight),
                     LFSR_DATA_NULL());
 
         // need a new hole?
-        } else if (lfsr_attr_size(attr) == 0) {
+        } else if (lfsr_rattr_size(rattr) == 0) {
             bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub));
-            attrs[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_DATA, +(weight + attr.weight),
+            rattrs[rattr_count++] = LFSR_RATTR(
+                    LFSR_TAG_DATA, +(weight + rattr.weight),
                     LFSR_DATA_NULL());
 
         // append new fragment/bptr?
         } else {
             bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub));
-            attrs[attr_count++] = LFSR_ATTR_(
-                    attr.tag, +(weight + attr.weight),
-                    attr.cat, attr.count);
+            rattrs[rattr_count++] = LFSR_RATTR_(
+                    rattr.tag, +(weight + rattr.weight),
+                    rattr.cat, rattr.count);
         }
     }
 
     // and don't forget the right sibling
-    if (right_attr_.tag) {
-        attrs[attr_count++] = right_attr_;
+    if (right_rattr_.tag) {
+        rattrs[rattr_count++] = right_rattr_;
     }
 
-    // commit pending attrs
-    if (attr_count > 0) {
-        LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t));
+    // commit pending rattrs
+    if (rattr_count > 0) {
+        LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t));
 
         int err = lfsr_file_commit(lfs, file, bid,
-                attrs, attr_count);
+                rattrs, rattr_count);
         if (err) {
             return err;
         }
@@ -12590,7 +12590,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
         uint8_t bptr_buf[LFSR_BPTR_DSIZE];
         err = lfsr_file_carve(lfs, file,
                 block_start, block_end - block_start,
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_BLOCK, 0,
                     LFSR_DATA_BPTR_(&bptr, bptr_buf)));
         if (err) {
@@ -12723,7 +12723,7 @@ fragment:;
         // our tree
         int err = lfsr_file_carve(lfs, file,
                 fragment_start, fragment_end - fragment_start,
-                LFSR_ATTR_CAT_(
+                LFSR_RATTR_CAT_(
                     LFSR_TAG_DATA, 0,
                     datas, data_count));
         if (err && err != LFS_ERR_RANGE) {
@@ -12998,8 +12998,8 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
             || lfsr_o_isunsync(file->o.o.flags));
 
     // build a commit of any pending file metadata
-    lfsr_attr_t attrs[3];
-    lfs_size_t attr_count = 0;
+    lfsr_rattr_t rattrs[3];
+    lfs_size_t rattr_count = 0;
     lfsr_data_t name_data;
     uint8_t buf[LFSR_BTREE_DSIZE];
 
@@ -13013,7 +13013,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
             goto failed;
         }
 
-        attrs[attr_count++] = LFSR_ATTR_CAT_(
+        rattrs[rattr_count++] = LFSR_RATTR_CAT_(
                 LFSR_TAG_SUB | LFSR_TAG_REG, 0,
                 &name_data, 1);
     }
@@ -13026,24 +13026,24 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
             goto failed;
         }
 
-        // null? no attr?
+        // null? no rattr?
         if (lfsr_o_isunflush(file->o.o.flags) && file->buffer.size == 0) {
-            attrs[attr_count++] = LFSR_ATTR(
+            rattrs[rattr_count++] = LFSR_RATTR(
                     LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_STRUCT, 0,
                     LFSR_DATA_NULL());
         // small file inlined in mdir?
         } else if (lfsr_o_isunflush(file->o.o.flags)) {
-            attrs[attr_count++] = LFSR_ATTR_CAT_(
+            rattrs[rattr_count++] = LFSR_RATTR_CAT_(
                     LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                     (const lfsr_data_t*)&file->buffer, 1);
         // bshrub?
         } else if (lfsr_bshrub_isbshrub(&file->o.o.mdir, &file->o.bshrub)) {
-            attrs[attr_count++] = LFSR_ATTR_SHRUBTRUNK(
+            rattrs[rattr_count++] = LFSR_RATTR_SHRUBTRUNK(
                     LFSR_TAG_SUB | LFSR_TAG_SHRUBTRUNK, 0,
                     &file->o.bshrub.u.bshrub);
         // btree?
         } else if (lfsr_bshrub_isbtree(&file->o.o.mdir, &file->o.bshrub)) {
-            attrs[attr_count++] = LFSR_ATTR(
+            rattrs[rattr_count++] = LFSR_RATTR(
                     LFSR_TAG_SUB | LFSR_TAG_BTREE, 0,
                     LFSR_DATA_BTREE_(&file->o.bshrub.u.btree, buf));
         } else {
@@ -13056,8 +13056,8 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
     // this gets real messy, since users can change custom attributes
     // whenever they want without informing littlefs, the best we can do
     // is read from disk to manually check if any attributes changed
-    bool uattrs = lfsr_o_isunsync(file->o.o.flags);
-    if (!uattrs) {
+    bool attrs = lfsr_o_isunsync(file->o.o.flags);
+    if (!attrs) {
         for (lfs_size_t i = 0; i < file->cfg->attr_count; i++) {
             // skip readonly attrs and lazy attrs
             if (lfsr_o_isrdonly(file->cfg->attrs[i].flags)
@@ -13075,7 +13075,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
             }
 
             // does disk match our attr?
-            lfs_scmp_t cmp = lfsr_uattr_cmp(lfs, &file->cfg->attrs[i],
+            lfs_scmp_t cmp = lfsr_attr_cmp(lfs, &file->cfg->attrs[i],
                     (err != LFS_ERR_NOENT) ? &data : NULL);
             if (cmp < 0) {
                 err = cmp;
@@ -13083,27 +13083,27 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
             }
 
             if (cmp != LFS_CMP_EQ) {
-                uattrs = true;
+                attrs = true;
                 break;
             }
         }
     }
-    if (uattrs) {
+    if (attrs) {
         // need to append custom attributes
-        attrs[attr_count++] = LFSR_ATTR_UATTRS(
-                LFSR_TAG_UATTRS, 0,
+        rattrs[rattr_count++] = LFSR_RATTR_ATTRS(
+                LFSR_TAG_ATTRS, 0,
                 file->cfg->attrs, file->cfg->attr_count);
     }
 
     // pending metadata? looks like we need to write to disk
-    if (attr_count > 0) {
+    if (rattr_count > 0) {
         // checkpoint the allocator
         lfs_alloc_ckpoint(lfs);
 
         // commit!
-        LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t));
+        LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t));
         err = lfsr_mdir_commit(lfs, &file->o.o.mdir,
-                attrs, attr_count);
+                rattrs, rattr_count);
         if (err) {
             goto failed;
         }
@@ -13154,13 +13154,13 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
                             continue;
                         }
 
-                        if (lfsr_uattr_isnoattr(&file->cfg->attrs[i])) {
+                        if (lfsr_attr_isnoattr(&file->cfg->attrs[i])) {
                             if (file_->cfg->attrs[j].size) {
                                 *file_->cfg->attrs[j].size = LFS_ERR_NOATTR;
                             }
                         } else {
                             lfs_size_t d = lfs_min(
-                                    lfsr_uattr_size(&file->cfg->attrs[i]),
+                                    lfsr_attr_size(&file->cfg->attrs[i]),
                                     file_->cfg->attrs[j].buffer_size);
                             memcpy(file_->cfg->attrs[j].buffer,
                                     file->cfg->attrs[i].buffer,
@@ -13346,7 +13346,7 @@ int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) {
         // truncate our btree 
         err = lfsr_file_carve(lfs, file,
                 lfs_min(size, size_), size - lfs_min(size, size_),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +size_ - size,
                     LFSR_DATA_NULL()));
         if (err) {
@@ -13468,7 +13468,7 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) {
         // fruncate our btree
         err = lfsr_file_carve(lfs, file,
                 0, lfs_smax(size - size_, 0),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +size_ - size,
                     LFSR_DATA_NULL()));
         if (err) {
@@ -13811,7 +13811,7 @@ static int lfs_init(lfs_t *lfs, uint32_t flags,
             + (lfs_nlog2(lfs->file_limit+1)+7-1)/7
             + (lfs_nlog2(lfs->cfg->block_size)+7-1)/7;
     LFS_ASSERT(tag_estimate <= LFSR_TAG_DSIZE);
-    lfs->attr_estimate = 3*tag_estimate + 4;
+    lfs->rattr_estimate = 3*tag_estimate + 4;
 
     // calculate the number of bits we need to reserve for mdir rids
     //
@@ -14540,30 +14540,30 @@ static int lfsr_formatinited(lfs_t *lfs) {
         // - our magic string, "littlefs"
         // - any format-time configuration
         // - the root's bookmark tag, which reserves did = 0 for the root
-        err = lfsr_rbyd_commit(lfs, &rbyd, -1, LFSR_ATTRS(
-                LFSR_ATTR(
+        err = lfsr_rbyd_commit(lfs, &rbyd, -1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_MAGIC, 0,
                     LFSR_DATA_BUF("littlefs", 8)),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_VERSION, 0,
                     LFSR_DATA_BUF(((const uint8_t[2]){
                         LFS_DISK_VERSION_MAJOR,
                         LFS_DISK_VERSION_MINOR}), 2)),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_RCOMPAT, 0,
                     LFSR_DATA_RCOMPAT(LFSR_RCOMPAT_COMPAT)),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_GEOMETRY, 0,
                     LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){
                         lfs->cfg->block_size,
                         lfs->cfg->block_count}))),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_NAMELIMIT, 0,
                     LFSR_DATA_LLEB128(lfs->name_limit)),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_FILELIMIT, 0,
                     LFSR_DATA_LEB128(lfs->file_limit)),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_BOOKMARK, +1,
                     LFSR_DATA_LEB128(0))));
         if (err) {
@@ -14737,8 +14737,8 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) {
         // checkpoint the allocator
         lfs_alloc_ckpoint(lfs);
         // remove the rid while atomically updating our grm
-        err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
+        err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
         if (err) {
             // revert grm manually
             lfs->grm = grm_p;
@@ -14780,8 +14780,8 @@ static int lfsr_fs_fixorphans_(lfs_t *lfs, lfsr_mdir_t *mdir) {
                 lfsr_mid_rid(lfs, mdir->mid));
 
         lfs_alloc_ckpoint(lfs);
-        err = lfsr_mdir_commit(lfs, mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
+        err = lfsr_mdir_commit(lfs, mdir, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
         if (err) {
             goto failed;
         }
@@ -15046,8 +15046,8 @@ int lfsr_fs_grow(lfs_t *lfs, lfs_size_t block_count_) {
 
     // update our on-disk config
     lfs_alloc_ckpoint(lfs);
-    int err = lfsr_mdir_commit(lfs, &lfs->mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    int err = lfsr_mdir_commit(lfs, &lfs->mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_GEOMETRY, 0,
                 LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){
                     lfs->cfg->block_size,
diff --git a/lfs.h b/lfs.h
index 946b5228..23dc74c3 100644
--- a/lfs.h
+++ b/lfs.h
@@ -826,7 +826,7 @@ typedef struct lfs {
     lfs_off_t file_limit;
 
     int8_t recycle_bits;
-    uint8_t attr_estimate;
+    uint8_t rattr_estimate;
     uint8_t mdir_bits;
 
     // linked-list of opened mdirs
diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml
index 5ba7c332..4c2461ad 100644
--- a/tests/test_badblocks.toml
+++ b/tests/test_badblocks.toml
@@ -74,8 +74,8 @@ code = '''
             lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1);
 
             // add to btree
-            lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_DATA, +1,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -1848,8 +1848,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1);
 
         // add to btree
-        lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -3622,8 +3622,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1);
 
         // add to btree
-        lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index aed49bcb..287d212f 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -52,8 +52,8 @@ code = '''
 
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -93,10 +93,10 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -142,10 +142,10 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -192,12 +192,12 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -250,12 +250,12 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -313,8 +313,8 @@ code = '''
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     lfs_size_t n = 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         n += 1;
@@ -363,8 +363,8 @@ code = '''
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     lfs_size_t n = 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1)))) => 0;
         n += 1;
@@ -428,8 +428,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1);
 
         // add to btree
-        lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -497,8 +497,8 @@ code = '''
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     lfs_size_t n = 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +W,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         n += 1;
@@ -588,8 +588,8 @@ code = '''
         }
 
         // add to btree
-        lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +weight,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -698,11 +698,11 @@ code = '''
 
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
     // update the tree
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
@@ -743,17 +743,17 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
     // update the tree
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF("A", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF("B", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
@@ -801,23 +801,23 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
     // update the tree
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF("A", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF("B", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF("C", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
@@ -874,15 +874,15 @@ code = '''
     // create a tree with N elements
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
     // update the tree
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0;
     }
@@ -931,8 +931,8 @@ code = '''
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
@@ -952,8 +952,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % N;
 
         // update btree
-        lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0;
 
@@ -1017,15 +1017,15 @@ code = '''
     // create a tree with N elements
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +W,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
     // update the tree
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0;
     }
@@ -1090,8 +1090,8 @@ code = '''
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +W,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
@@ -1122,11 +1122,11 @@ code = '''
 
         // update btree
         lfsr_btree_commit(&lfs, &btree,
-                weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+                weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                         LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW, +weight-sim_weights[bid],
                         LFSR_DATA_NULL()))) => 0;
 
@@ -1232,11 +1232,11 @@ code = '''
 
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
     // pop!
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1253,8 +1253,8 @@ code = '''
             &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1288,13 +1288,13 @@ code = '''
 
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
     // pop!
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1318,8 +1318,8 @@ code = '''
             &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("B", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("B", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1360,13 +1360,13 @@ code = '''
 
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
     // pop!
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1390,8 +1390,8 @@ code = '''
             &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1432,15 +1432,15 @@ code = '''
 
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
     // pop!
-    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1471,8 +1471,8 @@ code = '''
             &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try to putting it back to see if things still work
-    lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("C", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("C", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1524,15 +1524,15 @@ code = '''
     // create a tree with N elements
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
-        lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+        lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     }
 
     printf("btree: w%d 0x%x.%x\n",
@@ -1561,8 +1561,8 @@ code = '''
             &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try recovering
-    lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_lookup(&lfs, &btree, i,
@@ -1603,15 +1603,15 @@ code = '''
     // create a tree with N elements
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
-        lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+        lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -1640,8 +1640,8 @@ code = '''
             &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try recovering
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0;
 
     lfsr_btree_lookup(&lfs, &btree, 0,
             &tag_, &weight_, &data_) => 0;
@@ -1685,8 +1685,8 @@ code = '''
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
@@ -1707,8 +1707,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % sim_size;
 
         // remove from btree
-        lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+        lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
         // remove from sim
         memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1));
@@ -1773,15 +1773,15 @@ code = '''
     // create a tree with N elements
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +W,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
-        lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0;
+        lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0;
     }
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -1809,8 +1809,8 @@ code = '''
             &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 
     // try recovering
-    lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("R", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("R", 1)))) => 0;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_lookup(&lfs, &btree, i*W+W-1,
@@ -1899,8 +1899,8 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +weight,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -1921,8 +1921,8 @@ code = '''
 
         // remove from btree
         lfsr_btree_commit(&lfs, &btree,
-                weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+                weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM, -sim_weights[bid],
                         LFSR_DATA_NULL()))) => 0;
 
@@ -2028,17 +2028,17 @@ code = '''
 
     // create a tree with N elements
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_DATA, +1,
                 LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0;
     lfs_size_t n = 1;
     for (lfs_size_t i = 1; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i-1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))) => 0;
         n += 1;
@@ -2087,8 +2087,8 @@ code = '''
 
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -2105,11 +2105,11 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % sim_size;
 
         // split btree
-        lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0;
 
@@ -2176,17 +2176,17 @@ code = '''
 
     // create a tree with N elements
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_DATA, +W,
                 LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0;
     lfs_size_t n = 1;
     for (lfs_size_t i = 1; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +W,
                     LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))) => 0;
         n += 1;
@@ -2236,8 +2236,8 @@ code = '''
 
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("_", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -2267,14 +2267,14 @@ code = '''
 
         // split btree
         lfsr_btree_commit(&lfs, &btree,
-                weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+                weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW, +weight1-sim_weights[bid],
                         LFSR_DATA_NULL()),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_DATA, 0,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_DATA, +weight2,
                         LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0;
 
@@ -2416,28 +2416,28 @@ code = '''
     // force it to split
 
     // the extra push here avoids trying to inline the big entry
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
     uint8_t buf1[SIZE];
     memset(buf1, 'a', SIZE);
     uint8_t buf2[SIZE];
     memset(buf2, 'b', SIZE);
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)),
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)),
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(buf2, SIZE)))) => 0;
     assert(btree.weight == 2);
 
     // now remove one entry, since this brings the rbyd down to zero,
     // this should force one of the blocks to drop
-    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2483,20 +2483,20 @@ code = '''
     // force it to split
 
     // the extra push here avoids trying to inline the big entry
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
     uint8_t buf1[SIZE];
     memset(buf1, 'a', SIZE);
     uint8_t buf2[SIZE];
     memset(buf2, 'b', SIZE);
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)),
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)),
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(buf2, SIZE)))) => 0;
     assert(btree.weight == 2);
@@ -2506,8 +2506,8 @@ code = '''
     //
     // do this while forcing a compaction
     btree.eoff = -1;
-    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2553,15 +2553,15 @@ code = '''
     // force it to split
 
     // the extra push here avoids trying to inline the big entry
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
     uint8_t buf1[SIZE];
     memset(buf1, 'a', SIZE);
     uint8_t buf2[SIZE];
     memset(buf2, 'b', SIZE);
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)),
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)),
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0;
 
     // force compaction, causing a split, but while we're splitting,
     // also remove an entry, bringing the split rbyd down to zero mid split
@@ -2569,8 +2569,8 @@ code = '''
     // messy, isn't it? this is why we need an explicit test
     //
     btree.eoff = -1;
-    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2616,39 +2616,39 @@ code = '''
     // force it to split
 
     // the extra push here avoids trying to inline the big entry
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
     uint8_t buf1[SIZE];
     memset(buf1, 'a', SIZE);
     uint8_t buf2[SIZE];
     memset(buf2, 'b', SIZE);
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)),
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)),
+            LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(buf2, SIZE)))) => 0;
     assert(btree.weight == 2);
 
     // now make both entries small so they should be merged if either compacts
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF("a", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF("b", 1)))) => 0;
 
     // force compaction, while removing one entry, this drops the rbyd
     // down to zero while also triggering a merge
     btree.eoff = -1;
-    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2710,8 +2710,8 @@ code = '''
 
         if (op == 0 || bid == sim_size) {
             // push to btree
-            lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_DATA, +1,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -2722,8 +2722,8 @@ code = '''
 
         } else if (op == 1) {
             // update btree
-            lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -2732,8 +2732,8 @@ code = '''
 
         } else {
             // pop from btree
-            lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
             // pop from sim
             memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1));
@@ -2826,8 +2826,8 @@ code = '''
 
         if (op == 0 || bid == sim_size) {
             // push to btree
-            lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_DATA, +weight,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -2842,11 +2842,11 @@ code = '''
         } else if (op == 1) {
             // update btree
             lfsr_btree_commit(&lfs, &btree,
-                    weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
-                        LFSR_ATTR(
+                    weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                             LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
-                        LFSR_ATTR(
+                        LFSR_RATTR(
                             LFSR_TAG_GROW, +weight-sim_weights[bid],
                             LFSR_DATA_NULL()))) => 0;
 
@@ -2857,8 +2857,8 @@ code = '''
         } else {
             // remove from btree
             lfsr_btree_commit(&lfs, &btree,
-                    weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
-                        LFSR_ATTR(
+                    weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_RM, -sim_weights[bid],
                             LFSR_DATA_NULL()))) => 0;
 
@@ -2997,11 +2997,11 @@ code = '''
 
     // create a single-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 0, "aaa", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3049,17 +3049,17 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 0, "aaa", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR_NAME(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 0, "aab", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3115,23 +3115,23 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 0, "aaa", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR_NAME(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 1*DID, "aab", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
-            LFSR_ATTR_NAME(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 2*DID, "aac", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3195,23 +3195,23 @@ code = '''
 
     // create a two-entry tree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 0, "aaa", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
-            LFSR_ATTR_NAME(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 2*DID, "aac", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR_NAME(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 1*DID, "aab", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3279,11 +3279,11 @@ code = '''
     char name[3] = {
         'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26)
     };
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 0, name, 3),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
     lfs_size_t n = 1;
@@ -3291,14 +3291,14 @@ code = '''
         char name[3] = {
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
-        lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i-1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
-                LFSR_ATTR_NAME(
+                LFSR_RATTR_NAME(
                     LFSR_TAG_NAME, +1,
                     i*DID, name, 3),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))) => 0;
         n += 1;
@@ -3349,11 +3349,11 @@ code = '''
 
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 0, "___", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -3386,14 +3386,14 @@ code = '''
         }
 
         // split btree
-        lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
-                LFSR_ATTR_NAME(
+                LFSR_RATTR_NAME(
                     LFSR_TAG_NAME, +1,
                     0, name, 3),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0;
 
@@ -3466,11 +3466,11 @@ code = '''
     char name[3] = {
         'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26)
     };
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +W,
                 0, name, 3),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
     lfs_size_t n = 1;
@@ -3478,14 +3478,14 @@ code = '''
         char name[3] = {
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
-        lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
-                LFSR_ATTR_NAME(
+                LFSR_RATTR_NAME(
                     LFSR_TAG_NAME, +W,
                     i*DID, name, 3),
-                LFSR_ATTR(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))) => 0;
         n += 1;
@@ -3537,11 +3537,11 @@ code = '''
 
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +W,
                 0, "___", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -3587,17 +3587,17 @@ code = '''
 
         // split btree
         lfsr_btree_commit(&lfs, &btree,
-                weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+                weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW, +weight1-sim_weights[bid],
                         LFSR_DATA_NULL()),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_DATA, 0,
                         LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
-                    LFSR_ATTR_NAME(
+                    LFSR_RATTR_NAME(
                         LFSR_TAG_NAME, +weight2,
                         0, name, 3),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_DATA, 0,
                         LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0;
 
@@ -3693,11 +3693,11 @@ code = '''
 
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +1,
                 0, "___", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -3744,23 +3744,23 @@ code = '''
             assert(cmp != LFS_CMP_EQ);
             if (cmp > LFS_CMP_EQ) {
                 lfsr_btree_commit(&lfs, &btree,
-                        split_bid, LFSR_ATTRS(
-                            LFSR_ATTR_NAME(
+                        split_bid, LFSR_RATTRS(
+                            LFSR_RATTR_NAME(
                                 LFSR_TAG_NAME, +1,
                                 0, name, 3),
-                            LFSR_ATTR(
+                            LFSR_RATTR(
                                 LFSR_TAG_DATA, 0,
                                 LFSR_DATA_BUF(
                                     &(uint8_t){'0'+(i % 10)}, 1)))) => 0;
             } else {
-                lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
-                        LFSR_ATTR_CAT_(
+                lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS(
+                        LFSR_RATTR_CAT_(
                             LFSR_TAG_DATA, 0,
                             &split_data, 1),
-                        LFSR_ATTR_NAME(
+                        LFSR_RATTR_NAME(
                             LFSR_TAG_NAME, +1,
                             0, name, 3),
-                        LFSR_ATTR(
+                        LFSR_RATTR(
                             LFSR_TAG_DATA, 0,
                             LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0;
             }
@@ -3774,8 +3774,8 @@ code = '''
 
         } else if (op == 1) {
             // update btree
-            lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                         LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0;
 
@@ -3784,8 +3784,8 @@ code = '''
 
         } else {
             // pop from btree
-            lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
             // pop from sim
             memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1));
@@ -3850,11 +3850,11 @@ code = '''
 
     // create a btree
     lfsr_btree_t btree = LFSR_BTREE_NULL();
-    lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_NAME, +W,
                 0, "___", 3),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
+            LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -3913,23 +3913,23 @@ code = '''
             assert(cmp != LFS_CMP_EQ);
             if (cmp > LFS_CMP_EQ) {
                 lfsr_btree_commit(&lfs, &btree,
-                        split_bid-(split_weight-1), LFSR_ATTRS(
-                            LFSR_ATTR_NAME(
+                        split_bid-(split_weight-1), LFSR_RATTRS(
+                            LFSR_RATTR_NAME(
                                 LFSR_TAG_NAME, +weight,
                                 0, name, 3),
-                            LFSR_ATTR(
+                            LFSR_RATTR(
                                 LFSR_TAG_DATA, 0,
                                 LFSR_DATA_BUF(
                                     &(uint8_t){'0'+(i % 10)}, 1)))) => 0;
             } else {
-                lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
-                        LFSR_ATTR_CAT_(
+                lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS(
+                        LFSR_RATTR_CAT_(
                             LFSR_TAG_DATA, 0,
                             &split_data, 1),
-                        LFSR_ATTR_NAME(
+                        LFSR_RATTR_NAME(
                             LFSR_TAG_NAME, +weight,
                             0, name, 3),
-                        LFSR_ATTR(
+                        LFSR_RATTR(
                             LFSR_TAG_DATA, 0,
                             LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0;
             }
@@ -3947,11 +3947,11 @@ code = '''
         } else if (op == 1) {
             // update btree
             lfsr_btree_commit(&lfs, &btree,
-                    weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
-                        LFSR_ATTR(
+                    weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
                             LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
-                        LFSR_ATTR(
+                        LFSR_RATTR(
                             LFSR_TAG_GROW, +weight-sim_weights[bid],
                             LFSR_DATA_NULL()))) => 0;
 
@@ -3962,8 +3962,8 @@ code = '''
         } else {
             // pop from btree
             lfsr_btree_commit(&lfs, &btree,
-                    weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
-                        LFSR_ATTR(
+                    weighted_bid+sim_weights[bid]-1, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_RM, -sim_weights[bid],
                             LFSR_DATA_NULL()))) => 0;
 
@@ -4057,8 +4057,8 @@ code = '''
     lfsr_btree_t btree = LFSR_BTREE_NULL();
     lfs_size_t n = 0;
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         n += 1;
@@ -4193,8 +4193,8 @@ code = '''
         lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1);
 
         // add to btree
-        lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_DATA, +1,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
diff --git a/tests/test_mount.toml b/tests/test_mount.toml
index d16f1c39..2fbea650 100644
--- a/tests/test_mount.toml
+++ b/tests/test_mount.toml
@@ -515,8 +515,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_MAGIC, 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_unmount(&lfs) => 0;
@@ -539,8 +539,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_MAGIC, 0,
                 LFSR_DATA_BUF("lottlefs", 8)))) => 0;
     lfsr_unmount(&lfs) => 0;
@@ -563,8 +563,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_VERSION, 0,
                 LFSR_DATA_BUF(((const uint8_t[2]){
                     LFS_DISK_VERSION_MAJOR+1,
@@ -589,8 +589,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_VERSION, 0,
                 LFSR_DATA_BUF(((const uint8_t[2]){
                     LFS_DISK_VERSION_MAJOR,
@@ -616,8 +616,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RCOMPAT, 0,
                 LFSR_DATA_RCOMPAT(
                     LFSR_RCOMPAT_COMPAT
@@ -643,8 +643,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_WCOMPAT, 0,
                 LFSR_DATA_WCOMPAT(
                     LFSR_WCOMPAT_COMPAT
@@ -673,8 +673,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_OCOMPAT, 0,
                 LFSR_DATA_OCOMPAT(
                     LFSR_OCOMPAT_COMPAT
@@ -701,8 +701,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR_CAT(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR_CAT(
                 LFSR_TAG_RCOMPAT, 0,
                 LFSR_DATA_RCOMPAT(LFSR_RCOMPAT_COMPAT),
                 LFSR_DATA_BUF("\x00\x00\x00\x00\x80", 5)))) => 0;
@@ -725,8 +725,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR_CAT(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR_CAT(
                 LFSR_TAG_WCOMPAT, 0,
                 LFSR_DATA_WCOMPAT(LFSR_WCOMPAT_COMPAT),
                 LFSR_DATA_BUF("\x00\x00\x00\x00\x80", 5)))) => 0;
@@ -752,8 +752,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR_CAT(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR_CAT(
                 LFSR_TAG_OCOMPAT, 0,
                 LFSR_DATA_OCOMPAT(LFSR_OCOMPAT_COMPAT),
                 LFSR_DATA_BUF("\x00\x00\x00\x00\x80", 5)))) => 0;
@@ -780,8 +780,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_GEOMETRY, 0,
                 LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){
                     INC_BLOCK_SIZE,
@@ -807,8 +807,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_GEOMETRY, 0,
                 LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){
                     BLOCK_SIZE,
@@ -834,8 +834,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_NAMELIMIT, 0,
                 LFSR_DATA_LLEB128(INC_NAME_LIMIT)))) => 0;
     lfsr_unmount(&lfs) => 0;
@@ -858,8 +858,8 @@ code = '''
     // note we're messing around with internals to do this! this
     // is not a user API
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR_CAT(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR_CAT(
                 LFSR_TAG_FILELIMIT, 0,
                 // it's a bit difficult to test this since file limit
                 // is usually our integer limit, but we can force a
@@ -884,8 +884,8 @@ code = '''
 
     // create an unknown config
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_CONFIG + 0x13, 0,
                 LFSR_DATA_BUF("oh no!", strlen("oh no!"))))) => 0;
     lfsr_unmount(&lfs) => 0;
@@ -932,8 +932,8 @@ code = '''
     lfsr_mtree_pathlookup(&lfs, "b",
             &mdir, NULL,
             &did, &name, &name_size) => LFS_ERR_EXIST;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR_NAME(
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR_NAME(
                 LFSR_TAG_SUB | (LFSR_TAG_NAME + 0x13), 0,
                 did, name, name_size))) => 0;
     lfsr_unmount(&lfs) => 0;
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index bcb938d2..68bca3d5 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -15,7 +15,7 @@ code = '''
 '''
 
 # test a single mroot with attributes
-[cases.test_mtree_mroot_attrs]
+[cases.test_mtree_mroot_rattrs]
 defines.N = [1, 3]
 in = 'lfs.c'
 code = '''
@@ -25,8 +25,8 @@ code = '''
     lfs_alloc_ckpoint(&lfs);
 
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(i), 0,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
@@ -70,8 +70,8 @@ code = '''
         // force mroot to compact
         lfs.mroot.rbyd.eoff = -1;
 
-        lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(i), 0,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
@@ -112,8 +112,8 @@ code = '''
     lfs_alloc_ckpoint(&lfs);
 
     for (lfs_size_t i = 0; i < N; i++) {
-        lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(1), 0,
                     LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         lfsr_data_t data;
@@ -158,29 +158,29 @@ code = '''
     lfs_alloc_ckpoint(&lfs);
     lfsr_data_t data;
 
-    // create a 2 large attrs that needs to be uninlined
+    // create a 2 large rattrs that needs to be uninlined
     uint8_t buffer[SIZE];
     memset(buffer, 'a', SIZE);
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
 
     memset(buffer, 'b', SIZE);
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined
     assert(lfsr_mtree_weight_(&lfs.mtree) == (1 << lfs.mdir_bits));
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
-    // assert that our attrs are still in the mroot/mtree
+    // assert that our rattrs are still in the mroot/mtree
     lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
@@ -204,7 +204,7 @@ code = '''
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
-    // assert that our attrs are still in the mroot/mtree
+    // assert that our rattrs are still in the mroot/mtree
     lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
@@ -240,21 +240,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -325,21 +325,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -350,14 +350,14 @@ code = '''
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mdir to compact
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0;
 
     // assert mdir was split correctly
     assert(lfsr_mtree_weight_(&lfs.mtree) == (3 << lfs.mdir_bits));
@@ -455,8 +455,8 @@ code = '''
             lfs.mroot.rbyd.eoff = -1;
             mdir.rbyd.eoff = -1;
         }
-        lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+        lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
         lfsr_data_t data;
 
         uint8_t buffer[256];
@@ -553,8 +553,8 @@ code = '''
             lfs.mroot.rbyd.eoff = -1;
             mdir.rbyd.eoff = -1;
         }
-        lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+        lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
         lfsr_data_t data;
 
         // double check
@@ -636,21 +636,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -661,8 +661,8 @@ code = '''
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped
@@ -722,21 +722,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -749,8 +749,8 @@ code = '''
             &mdir, NULL, NULL) => 0;
     // force mdir to compact while we're removing
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped
@@ -810,15 +810,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // remove an entry, forcing the mdir to be dropped
@@ -828,8 +828,8 @@ code = '''
     // force mdir to compact while we're removing
     lfs.mroot.rbyd.eoff = -1;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // assert split/drop worked out
@@ -881,21 +881,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -906,8 +906,8 @@ code = '''
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // remove an entry, forcing the mdir to be dropped
@@ -916,8 +916,8 @@ code = '''
             &mdir, NULL, NULL) => 0;
     // force mdir to compact while we're removing
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 1);
 
     // assert split/drop worked out
@@ -989,21 +989,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -1014,8 +1014,8 @@ code = '''
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // remove an entry, forcing the mdir to be dropped
@@ -1024,8 +1024,8 @@ code = '''
             &mdir, NULL, NULL) => 0;
     // force mdir to compact while we're removing
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 1);
 
     // assert split/drop worked out
@@ -1124,8 +1124,8 @@ code = '''
                 lfs.mroot.rbyd.eoff = -1;
                 mdir.rbyd.eoff = -1;
             }
-            lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+            lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
             lfsr_data_t data;
 
             // double check
@@ -1152,8 +1152,8 @@ code = '''
                 lfs.mroot.rbyd.eoff = -1;
                 mdir.rbyd.eoff = -1;
             }
-            lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
         }
     }
 
@@ -1224,22 +1224,22 @@ code = '''
     lfs_alloc_ckpoint(&lfs);
     lfsr_data_t data;
 
-    // create a 2 large attrs that needs to be uninlined
+    // create a 2 large rattrs that needs to be uninlined
     uint8_t buffer[SIZE];
     memset(buffer, 'a', SIZE);
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
 
     memset(buffer, 'b', SIZE);
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined
     assert(lfsr_mtree_weight_(&lfs.mtree) == (1 << lfs.mdir_bits));
@@ -1250,11 +1250,11 @@ code = '''
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
     lfsr_mdir_t old_mdir = mdir;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("d", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("d", 1)))) => 0;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("e", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("e", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -1263,7 +1263,7 @@ code = '''
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
-    // assert that our attrs are still in the mroot/mtree
+    // assert that our rattrs are still in the mroot/mtree
     lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
@@ -1297,7 +1297,7 @@ code = '''
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
-    // assert that our attrs are still in the mroot/mtree
+    // assert that our rattrs are still in the mroot/mtree
     lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
@@ -1345,21 +1345,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -1372,11 +1372,11 @@ code = '''
             &mdir, NULL, NULL) => 0;
     lfsr_mdir_t old_mdir = mdir;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -1471,21 +1471,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -1498,11 +1498,11 @@ code = '''
             &mdir, NULL, NULL) => 0;
     lfsr_mdir_t old_mdir = mdir;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -1597,18 +1597,18 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfsr_mdir_t old_mroot = lfs.mroot;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
@@ -1631,7 +1631,7 @@ code = '''
     lfsr_unmount(&lfs) => 0;
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
 
-    // assert that our attr is still in the mroot
+    // assert that our rattr is still in the mroot
     lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
     lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
@@ -1672,18 +1672,18 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfsr_mdir_t old_mroot = lfs.mroot;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
@@ -1691,21 +1691,21 @@ code = '''
     // twice, forcing a second mroot extension
     old_mroot = lfs.mroot;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("f", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("f", 1)))) => 0;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("g", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("g", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
-    // assert that our attr is still in the mroot
+    // assert that our rattr is still in the mroot
     lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
     lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
@@ -1740,7 +1740,7 @@ code = '''
     lfsr_unmount(&lfs) => 0;
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
 
-    // assert that our attr is still in the mroot
+    // assert that our rattr is still in the mroot
     lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
     lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
@@ -1794,29 +1794,29 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
     lfsr_mdir_t old_mroot = lfs.mroot;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
     // force mroot to compact twice again, this should relocate the mroot
     old_mroot = lfs.mroot;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
@@ -1847,7 +1847,7 @@ code = '''
     lfsr_unmount(&lfs) => 0;
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
 
-    // assert that our attr is still in the mroot
+    // assert that our rattr is still in the mroot
     lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
     lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
@@ -1893,21 +1893,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -1923,11 +1923,11 @@ code = '''
             &mdir, NULL, NULL) => 0;
     lfsr_mdir_t old_mdir = mdir;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
     // assert mroot relocated
@@ -2024,21 +2024,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -2049,8 +2049,8 @@ code = '''
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // setup mroot to compact and relocate on next commit
@@ -2059,11 +2059,11 @@ code = '''
     // force mdir to compact twice, this should relocate
     lfsr_mdir_t old_mdir = mdir;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("f", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("f", 1)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
     // assert mroot relocated
@@ -2168,21 +2168,21 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits));
@@ -2198,12 +2198,12 @@ code = '''
             &mdir, NULL, NULL) => 0;
     // force mdir to compact twice, this should relocate
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0;
     // force mdir to compact while we're removing
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 0);
     // assert mroot relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2265,23 +2265,23 @@ code = '''
     lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0;
     lfsr_data_t data;
 
-    // create a 2 large attrs that needs to be uninlined
+    // create a 2 large rattrs that needs to be uninlined
     uint8_t buffer[SIZE];
     memset(buffer, 'a', SIZE);
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
 
     memset(buffer, 'b', SIZE);
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact, this should both uninline and relocate
     lfsr_mdir_t old_mroot = lfs.mroot;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0;
     // assert mroot relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
@@ -2290,7 +2290,7 @@ code = '''
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
-    // assert that our attrs are still in the mroot/mtree
+    // assert that our rattrs are still in the mroot/mtree
     lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
@@ -2314,7 +2314,7 @@ code = '''
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
-    // assert that our attrs are still in the mroot/mtree
+    // assert that our rattrs are still in the mroot/mtree
     lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
@@ -2357,22 +2357,22 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact, this should both split and relocate
     lfsr_mdir_t old_mroot = lfs.mroot;
     lfs.mroot.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0;
     // assert mroot relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
@@ -2474,8 +2474,8 @@ code = '''
                 lfs.mroot.rbyd.eoff = -1;
                 mdir.rbyd.eoff = -1;
             }
-            lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+            lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
             lfsr_data_t data;
 
             // double check
@@ -2503,8 +2503,8 @@ code = '''
             }
             // we can't really change metadata names, but commits still
             // trigger writes to the mdir
-            lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(name, 4)))) => 0;
+            lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(name, 4)))) => 0;
             lfsr_data_t data;
 
             // double check
@@ -2531,8 +2531,8 @@ code = '''
                 lfs.mroot.rbyd.eoff = -1;
                 mdir.rbyd.eoff = -1;
             }
-            lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
         }
     }
 
@@ -2601,16 +2601,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "c", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0c", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0c", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -2618,8 +2618,8 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, "b", 1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0;
     assert(mdir.rbyd.weight == 4);
     lfsr_data_t data;
 
@@ -2660,16 +2660,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "b", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -2677,8 +2677,8 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // assert neighbor was removed
@@ -2710,16 +2710,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "b", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -2727,8 +2727,8 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, "b", 1,
             &mdir, NULL, NULL) => 0;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // assert neighbor was removed
@@ -2762,16 +2762,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "d", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -2782,15 +2782,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -2835,16 +2835,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "e", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -2855,15 +2855,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -2874,8 +2874,8 @@ code = '''
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     // force mdir to compact
@@ -2920,16 +2920,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "b", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -2978,16 +2978,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "d", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -2998,15 +2998,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -3024,11 +3024,11 @@ code = '''
             &mdir, NULL, NULL) => 0;
     lfsr_mdir_t old_mdir = mdir;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -3067,16 +3067,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "d", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -3087,15 +3087,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -3113,11 +3113,11 @@ code = '''
             &mdir, NULL, NULL) => 0;
     lfsr_mdir_t old_mdir = mdir;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     mdir.rbyd.eoff = -1;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -3154,16 +3154,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "f", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0f", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0f", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -3174,15 +3174,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'e', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -3193,8 +3193,8 @@ code = '''
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     // force mdir to compact
@@ -3210,8 +3210,8 @@ code = '''
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mdir to compact
@@ -3256,16 +3256,16 @@ code = '''
     lfsr_omdir_t left = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &left.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_omdir_open(&lfs, &left);
 
     lfsr_omdir_t right = {.flags=0};
     lfsr_mtree_namelookup(&lfs, 0, "e", 1,
             &right.mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_omdir_open(&lfs, &right);
 
@@ -3276,15 +3276,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -3295,8 +3295,8 @@ code = '''
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     // force mdir to compact
@@ -3309,8 +3309,8 @@ code = '''
     assert(lfs.mroot.rbyd.weight == 0);
 
     // now remove the middle entry, forcing a drop
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped correctly
@@ -3354,8 +3354,8 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // test that we can traverse the tree, keeping track of all blocks we see
@@ -3453,17 +3453,17 @@ code = '''
     lfs_alloc_ckpoint(&lfs);
     lfsr_data_t data;
 
-    // create a 2 large attrs that needs to be uninlined
+    // create a 2 large rattrs that needs to be uninlined
     uint8_t buffer[SIZE];
     memset(buffer, 'a', SIZE);
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
 
     memset(buffer, 'b', SIZE);
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
@@ -3539,7 +3539,7 @@ code = '''
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
-    // assert that our attrs are still in the mroot/mtree
+    // assert that our rattrs are still in the mroot/mtree
     lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
@@ -3559,7 +3559,7 @@ code = '''
     // assert mroot now has no entries
     assert(lfs.mroot.rbyd.weight == 0);
 
-    // assert that our attrs are still in the mroot/mtree
+    // assert that our rattrs are still in the mroot/mtree
     lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;
     assert(buffer[0] == 'a');
@@ -3592,15 +3592,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -3734,15 +3734,15 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -3758,8 +3758,8 @@ code = '''
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mdir to compact
@@ -3901,8 +3901,8 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, "a", 1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
@@ -4025,8 +4025,8 @@ code = '''
             lfs.mroot.rbyd.eoff = -1;
             mdir.rbyd.eoff = -1;
         }
-        lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+        lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
         lfsr_data_t data;
 
         uint8_t buffer[256];
@@ -4186,8 +4186,8 @@ code = '''
             lfs.mroot.rbyd.eoff = -1;
             mdir.rbyd.eoff = -1;
         }
-        lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+        lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
         lfsr_data_t data;
 
         // double check
@@ -4323,8 +4323,8 @@ code = '''
     lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
     lfs_alloc_ckpoint(&lfs);
 
-    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_MROOT, 0,
                 LFSR_DATA_MPTR(LFSR_MPTR_MROOTANCHOR())))) => 0;
 
@@ -4408,8 +4408,8 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
@@ -4465,8 +4465,8 @@ code = '''
     lfsr_mdir_t mdir;
     lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1,
             &mdir, NULL, NULL) => LFS_ERR_NOENT;
-    lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+    lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
@@ -4492,7 +4492,7 @@ code = '''
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
 
-    // assert that our attr is still in the mroot
+    // assert that our rattr is still in the mroot
     lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0;
     assert(mdir.rbyd.weight == 2);
     lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0;
diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml
index b9e61faa..0a6d0808 100644
--- a/tests/test_rbyd.toml
+++ b/tests/test_rbyd.toml
@@ -31,8 +31,8 @@ code = '''
     // commit with one attribute
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -40,11 +40,11 @@ code = '''
     // commit with two attributes
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -68,8 +68,8 @@ code = '''
     // commit with one attribute
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -77,12 +77,12 @@ code = '''
     // commit with two attributes
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -106,8 +106,8 @@ code = '''
     // commit with one attribute
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -115,8 +115,8 @@ code = '''
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 
     // commit with the second attribute
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -148,8 +148,8 @@ code = '''
     // commit with one attribute
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -173,11 +173,11 @@ code = '''
     // commit with two attributes
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -211,11 +211,11 @@ code = '''
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -268,8 +268,8 @@ code = '''
     // commit with one attribute
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -293,12 +293,12 @@ code = '''
     // commit with two attributes
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -332,12 +332,12 @@ code = '''
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -389,8 +389,8 @@ code = '''
     // commit with one attribute
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -410,11 +410,11 @@ code = '''
     // commit with two attributes
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -436,11 +436,11 @@ code = '''
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
@@ -479,8 +479,8 @@ code = '''
     // commit with one attribute
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -500,12 +500,12 @@ code = '''
     // commit with two attributes
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -527,12 +527,12 @@ code = '''
     // commit with two attributes, in the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0;
@@ -575,11 +575,11 @@ code = '''
     // 1      1  2
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -601,11 +601,11 @@ code = '''
     // 2      2  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -646,14 +646,14 @@ code = '''
     // 1  2      1  2  2
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -675,14 +675,14 @@ code = '''
     // 1  2      1  2  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -725,14 +725,14 @@ code = '''
     // 1  2      1  2  3
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -761,14 +761,14 @@ code = '''
     // 2  3      2  3  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -816,17 +816,17 @@ code = '''
     // 1  2  3      1  2  3  3
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -855,17 +855,17 @@ code = '''
     // 1  2  3      1  2  3  2
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -894,17 +894,17 @@ code = '''
     // 1  2  3      1  2  3  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -933,17 +933,17 @@ code = '''
     // 3  1  2      3  1  2  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -993,17 +993,17 @@ code = '''
     // 1  2  3      1  2  3  4
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
@@ -1039,17 +1039,17 @@ code = '''
     // 1  3  4      1  3  4  2      1  3  4  2
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -1085,17 +1085,17 @@ code = '''
     // 2  3  4      2  3  4  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -1131,17 +1131,17 @@ code = '''
     // 4  2  3      4  2  3  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -1196,17 +1196,17 @@ code = '''
     // 1  2  3      1  2  3  4
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
@@ -1242,17 +1242,17 @@ code = '''
     // 1  2  4      1  2  4  3
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -1288,17 +1288,17 @@ code = '''
     // 1  4  2      1  4  2  3      1  4  2  3
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -1334,17 +1334,17 @@ code = '''
     // 4  1  2      4  1  2  3      4  1  2  3
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -1401,20 +1401,20 @@ code = '''
     // 1  2  3  4      1  2  3  4  4
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
@@ -1452,20 +1452,20 @@ code = '''
     // 1  2  3  4      1  2  3  4  3
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -1501,20 +1501,20 @@ code = '''
     // 1  2  3  4      1  2  3  4  2
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -1550,20 +1550,20 @@ code = '''
     // 1  2  3  4      1  2  3  4  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -1622,20 +1622,20 @@ code = '''
     // 1  2  3  4      1  2  3  4  5
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
@@ -1680,20 +1680,20 @@ code = '''
     // 1  2  4  5      1  2  4  5  3
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -1736,20 +1736,20 @@ code = '''
     // 1  3  4  5      1  3  4  5  2
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -1792,20 +1792,20 @@ code = '''
     // 2  3  4  5      2  3  4  5  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -1869,23 +1869,23 @@ code = '''
     // 1  2  3  4  5      1  2  3  4  5  5
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
@@ -1930,23 +1930,23 @@ code = '''
     // 1  2  3  4  5      1  2  3  4  5  2
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -1991,23 +1991,23 @@ code = '''
     // 1  2  3  4  5      1  2  3  4  5  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -2073,23 +2073,23 @@ code = '''
     // 1  2  3  4  5      1  2  3  4  5  6
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xff\xff\xff\xff", 4)))) => 0;
 
@@ -2139,23 +2139,23 @@ code = '''
     // 1  3  4  5  6      1  3  4  5  6  2
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xff\xff\xff\xff", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -2205,23 +2205,23 @@ code = '''
     // 2  3  4  5  6      2  3  4  5  6  1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xff\xff\xff\xff", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -2304,9 +2304,9 @@ code = '''
         printf("] ---\n");
 
         // build the attribute list for the current permutation
-        struct lfsr_attr attrs[N];
+        struct lfsr_rattr rattrs[N];
         for (unsigned j = 0; j < N; j++) {
-            attrs[j] = LFSR_ATTR(
+            rattrs[j] = LFSR_RATTR(
                     LFSR_TAG_ATTR(perm[j]+1), 0,
                     LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4));
         }
@@ -2314,7 +2314,7 @@ code = '''
         // test the given permutation
         rbyd = init_rbyd;
         lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-        lfsr_rbyd_commit(&lfs, &rbyd, -1, attrs, N) => 0;
+        lfsr_rbyd_commit(&lfs, &rbyd, -1, rattrs, N) => 0;
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         for (unsigned j = 0; j < N; j++) {
@@ -2398,8 +2398,8 @@ code = '''
         rbyd = init_rbyd;
         lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(perm[j]+1), 0,
                         LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
@@ -2458,11 +2458,11 @@ code = '''
     // the tag requested
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -2496,11 +2496,11 @@ code = '''
     // also try the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -2555,12 +2555,12 @@ code = '''
     // the tag requested
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -2594,12 +2594,12 @@ code = '''
     // also try the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -2673,9 +2673,9 @@ code = '''
         printf("] ---\n");
 
         // build the attribute list for the current permutation
-        struct lfsr_attr attrs[N];
+        struct lfsr_rattr rattrs[N];
         for (unsigned j = 0; j < N; j++) {
-            attrs[j] = LFSR_ATTR(
+            rattrs[j] = LFSR_RATTR(
                     LFSR_TAG_ATTR(perm[j]+1), 0,
                     LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4));
         }
@@ -2683,7 +2683,7 @@ code = '''
         // test the given permutation
         rbyd = init_rbyd;
         lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-        lfsr_rbyd_commit(&lfs, &rbyd, -1, attrs, N) => 0;
+        lfsr_rbyd_commit(&lfs, &rbyd, -1, rattrs, N) => 0;
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         // try traversing all tags
@@ -2749,8 +2749,8 @@ code = '''
         rbyd = init_rbyd;
         lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(perm[j]+1), 0,
                         LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
@@ -2806,8 +2806,8 @@ code = '''
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
-        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(j+1), 0,
                     LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     }
@@ -2848,8 +2848,8 @@ code = '''
 
         // update each tag in permutation order
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(perm[j]+1), 0,
                         LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
         }
@@ -2927,8 +2927,8 @@ code = '''
                 = (ORDER == 0) ? i
                 : (ORDER == 1) ? (((lfs_size_t)-1) - i)
                 : TEST_PRNG(&prng);
-        int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                LFSR_ATTR(
+        int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(x & 0x7f), 0,
                     LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4))));
         if (err == LFS_ERR_RANGE) {
@@ -2979,12 +2979,12 @@ code = '''
     // add and remove one attribute
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()))) => 0;
 
@@ -3002,15 +3002,15 @@ code = '''
     // commit with two attributes, remove the first one
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()))) => 0;
 
@@ -3044,15 +3044,15 @@ code = '''
     // commit with two attributes, remove the second one
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_NULL()))) => 0;
 
@@ -3131,8 +3131,8 @@ code = '''
         rbyd = init_rbyd;
         lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(perm[j]+1), 0,
                         LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
@@ -3156,8 +3156,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_ATTR(j+1), 0,
                         LFSR_DATA_NULL()))) => 0;
 
@@ -3185,8 +3185,8 @@ code = '''
 
             // try appending the tag back to make sure things still work
             printf("--- append: %d ---\n", j);
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(j+1), 0,
                         LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
 
@@ -3281,8 +3281,8 @@ code = '''
         rbyd = init_rbyd;
         lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(perm[j]+1), 0,
                         LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
@@ -3306,8 +3306,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_ATTR(j+1), 0,
                         LFSR_DATA_NULL()))) => 0;
 
@@ -3360,11 +3360,11 @@ code = '''
     // create a tree two attributes
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3391,8 +3391,8 @@ code = '''
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
     // try to remove tags that aren't there, this should do nothing
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3418,8 +3418,8 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3445,8 +3445,8 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3519,31 +3519,31 @@ code = '''
     // create a tree
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
     // remove several attributes
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_NULL()))) => 0;
 
@@ -3571,8 +3571,8 @@ code = '''
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
     // try to remove tags that aren't there, this should do nothing
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3598,8 +3598,8 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3625,8 +3625,8 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3654,8 +3654,8 @@ code = '''
 
     // try to remove the tags again, just to make sure (keep in mind
     // these removes still commit to the rbyd)
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3681,8 +3681,8 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3708,8 +3708,8 @@ code = '''
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1),
@@ -3782,12 +3782,12 @@ code = '''
     // commit with one attribute, remove it
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()))) => 0;
 
@@ -3805,18 +3805,18 @@ code = '''
     // commit with two attributes, remove both
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_NULL()))) => 0;
 
@@ -3834,18 +3834,18 @@ code = '''
     // commit with two attributes, remove both in the other order
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()))) => 0;
 
@@ -3896,8 +3896,8 @@ code = '''
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
-        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(j+1), 0,
                     LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     }
@@ -3938,8 +3938,8 @@ code = '''
 
         // remove each tag in permutation order
         for (unsigned j = 0; j < N; j++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_ATTR(perm[j]+1), 0,
                         LFSR_DATA_NULL()))) => 0;
         }
@@ -3952,8 +3952,8 @@ code = '''
         }
 
         // try resuming from all tags being removed
-        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(1), 0,
                     LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
 
@@ -4020,13 +4020,13 @@ code = '''
     printf("perm: [");
     uint32_t prng = SEED;
     for (unsigned i = 0; i < N; i++) {
-        // choose an attr
-        uint8_t attr = TEST_PRNG(&prng) % N;
+        // choose an rattr
+        uint8_t rattr = TEST_PRNG(&prng) % N;
         // choose append or remove
         if (TEST_PRNG(&prng) & 1) {
-            printf("a0x%02x=%c", attr, 'a'+(i % 26));
+            printf("a0x%02x=%c", rattr, 'a'+(i % 26));
         } else {
-            printf("r0x%02x", attr);
+            printf("r0x%02x", rattr);
         }
         if (i < N-1) {
             printf(", ");
@@ -4044,24 +4044,24 @@ code = '''
 
     prng = SEED;
     for (unsigned i = 0; i < N; i++) {
-        // choose an attr
-        uint8_t attr = TEST_PRNG(&prng) % N;
+        // choose an rattr
+        uint8_t rattr = TEST_PRNG(&prng) % N;
         // choose append or remove
         if (TEST_PRNG(&prng) & 1) {
             // update our sim
-            sim[attr] = 'a'+(i % 26);
+            sim[rattr] = 'a'+(i % 26);
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
-                        LFSR_TAG_ATTR(attr), 0,
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
+                        LFSR_TAG_ATTR(rattr), 0,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         } else {
             // update our sim
-            sim[attr] = '\0';
+            sim[rattr] = '\0';
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
-                        LFSR_TAG_RM | LFSR_TAG_ATTR(attr), 0,
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
+                        LFSR_TAG_RM | LFSR_TAG_ATTR(rattr), 0,
                         LFSR_DATA_NULL()))) => 0;
         }
     }
@@ -4069,20 +4069,20 @@ code = '''
     // compare rbyd vs simulation
     printf("expd: [");
     bool first = true;
-    for (unsigned attr = 0; attr < N; attr++) {
-        if (sim[attr]) {
+    for (unsigned rattr = 0; rattr < N; rattr++) {
+        if (sim[rattr]) {
             if (!first) {
                 printf(", ");
             }
             first = false;
-            printf("0x%02x=%c", attr, sim[attr]);
+            printf("0x%02x=%c", rattr, sim[rattr]);
         }
     }
     printf("]\n");
     printf("rbyd: [");
     first = true;
-    for (unsigned attr = 0; attr < N; attr++) {
-        int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(attr),
+    for (unsigned rattr = 0; rattr < N; rattr++) {
+        int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(rattr),
                 &data);
         if (!err) {
             lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
@@ -4090,19 +4090,19 @@ code = '''
                 printf(", ");
             }
             first = false;
-            printf("0x%02x=%.*s", attr, size, buffer);
+            printf("0x%02x=%.*s", rattr, size, buffer);
         }
     }
     printf("]\n");
 
-    for (unsigned attr = 0; attr < N; attr++) {
-        int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(attr),
+    for (unsigned rattr = 0; rattr < N; rattr++) {
+        int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(rattr),
                 &data);
-        if (sim[attr]) {
+        if (sim[rattr]) {
             assert(err == 0);
             lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4);
             assert(size == 1);
-            assert(memcmp(&sim[attr], buffer, 1) == 0);
+            assert(memcmp(&sim[rattr], buffer, 1) == 0);
         } else {
             assert(err == LFS_ERR_NOENT);
         }
@@ -4135,8 +4135,8 @@ code = '''
     // try to create one rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -4154,11 +4154,11 @@ code = '''
     // try to create two ids
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -4182,14 +4182,14 @@ code = '''
     // create a third to the right
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -4237,8 +4237,8 @@ code = '''
     // try to create one rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -4256,12 +4256,12 @@ code = '''
     // try to create two ids
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -4285,12 +4285,12 @@ code = '''
     // try to create two in the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -4314,16 +4314,16 @@ code = '''
     // create a third to the right
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -4353,16 +4353,16 @@ code = '''
     // create a third to the left
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -4392,16 +4392,16 @@ code = '''
     // create a third in the middle
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -4495,8 +4495,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -4557,11 +4557,11 @@ code = '''
     // the tag requested
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -4630,12 +4630,12 @@ code = '''
     // the tag requested
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -4681,12 +4681,12 @@ code = '''
     // also try the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -4795,8 +4795,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -4868,8 +4868,8 @@ code = '''
                 : (uint16_t)TEST_PRNG(&prng);
         x = x % (rbyd.weight+1);
 
-        int err = lfsr_rbyd_commit(&lfs, &rbyd, x, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4))));
+        int err = lfsr_rbyd_commit(&lfs, &rbyd, x, LFSR_RATTRS(
+                LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4))));
         if (err == LFS_ERR_RANGE) {
             break;
         }
@@ -4893,7 +4893,7 @@ code = '''
 '''
 
 
-### Mixed create and attr testing ###
+### Mixed create and rattr testing ###
 
 [cases.test_rbyd_atomic_mixed]
 in = 'lfs.c'
@@ -4915,11 +4915,11 @@ code = '''
     // try to create one rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
 
@@ -4943,17 +4943,17 @@ code = '''
     // try to create two ids
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
 
@@ -4989,23 +4989,23 @@ code = '''
     // create a third to the right
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
 
@@ -5094,12 +5094,12 @@ code = '''
     // try to create one rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
 
@@ -5123,20 +5123,20 @@ code = '''
     // try to create two ids
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
 
@@ -5172,20 +5172,20 @@ code = '''
     // try to create two in the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
 
@@ -5221,28 +5221,28 @@ code = '''
     // create a third to the right
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
 
@@ -5313,28 +5313,28 @@ code = '''
     // create a third to the left
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
 
@@ -5382,28 +5382,28 @@ code = '''
     // create a third in the middle
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
 
@@ -5516,14 +5516,14 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
-            // note uattrs have a smaller size to help debugging
+            // note urattrs have a smaller size to help debugging
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                        LFSR_ATTR(
+                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_ATTR(u+1), 0,
                             LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
             }
@@ -5591,17 +5591,17 @@ code = '''
     // the tag requested
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
 
@@ -5702,20 +5702,20 @@ code = '''
     // the tag requested
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
 
@@ -5793,20 +5793,20 @@ code = '''
     // also try the other direction
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
 
@@ -5948,14 +5948,14 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
-            // note uattrs have a smaller size to help debugging
+            // note urattrs have a smaller size to help debugging
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                        LFSR_ATTR(
+                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_ATTR(u+1), 0,
                             LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
             }
@@ -6038,14 +6038,14 @@ code = '''
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
-        lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_REG, +1,
                     LFSR_DATA_BUF(names[j % 6], 4)))) => 0;
-        // note uattrs have a smaller size to help debugging
+        // note urattrs have a smaller size to help debugging
         for (unsigned u = 0; u < M; u++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(u+1), 0,
                         LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
         }
@@ -6087,8 +6087,8 @@ code = '''
 
         // update each tag in permutation order
         for (unsigned j = 0; j < N*M; j++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(perm[j]%M+1), 0,
                         LFSR_DATA_BUF(names[(perm[j]/M) % 6], 3)))) => 0;
         }
@@ -6205,14 +6205,14 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
-            // note uattrs have a smaller size to help debugging
+            // note urattrs have a smaller size to help debugging
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                        LFSR_ATTR(
+                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_ATTR(u+1), 0,
                             LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
             }
@@ -6237,8 +6237,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_ATTR((j%M)+1), 0,
                         LFSR_DATA_NULL()))) => 0;
 
@@ -6281,8 +6281,8 @@ code = '''
 
             // try append the tag back to make sure things still work
             printf("--- append: rid%jd, %jd ---\n", j/M, (j%M)+1);
-            lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((j%M)+1), 0,
                         LFSR_DATA_BUF(names[(j/M)%6], 3)))) => 0;
 
@@ -6385,14 +6385,14 @@ code = '''
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
-        lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_REG, +1,
                     LFSR_DATA_BUF(names[j % 6], 4)))) => 0;
-        // note uattrs have a smaller size to help debugging
+        // note urattrs have a smaller size to help debugging
         for (unsigned u = 0; u < M; u++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(u+1), 0,
                         LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
         }
@@ -6434,8 +6434,8 @@ code = '''
 
         // remove each tag in permutation order
         for (unsigned j = 0; j < N*M; j++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_ATTR(perm[j]%M+1), 0,
                         LFSR_DATA_NULL()))) => 0;
         }
@@ -6525,17 +6525,19 @@ code = '''
                 : (uint16_t)TEST_PRNG(&prng);
         x = x % (rbyd.weight+1);
 
-        // build a single attribute list with all attributes, if this fails
+        // build a single attribute list with all rattributes, if this fails
         // it should fail atomically
-        struct lfsr_attr attrs[1+M];
-        attrs[0] = LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4));
+        struct lfsr_rattr rattrs[1+M];
+        rattrs[0] = LFSR_RATTR(
+                LFSR_TAG_REG, +1,
+                LFSR_DATA_BUF(names[x % 6], 4));
         for (unsigned u = 0; u < M; u++) {
-            attrs[1+u] = LFSR_ATTR(
+            rattrs[1+u] = LFSR_RATTR(
                     LFSR_TAG_ATTR(u+1), 0,
                     LFSR_DATA_BUF(names[x % 6], 2));
         }
 
-        int err = lfsr_rbyd_commit(&lfs, &rbyd, x, attrs, 1+M);
+        int err = lfsr_rbyd_commit(&lfs, &rbyd, x, rattrs, 1+M);
         if (err == LFS_ERR_RANGE) {
             break;
         }
@@ -6636,13 +6638,13 @@ code = '''
             }
 
             // note the data size differences here
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(perm[j]+1), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -6782,18 +6784,18 @@ code = '''
             }
 
             // note the data size differences here
-            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(perm[j]+1), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                        LFSR_ATTR(
+                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_ATTR(u+1), 0,
                             LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
             }
@@ -6907,15 +6909,15 @@ code = '''
     // try to delete one rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -6935,15 +6937,15 @@ code = '''
     // try to delete the other rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -6963,18 +6965,18 @@ code = '''
     // try to delete the largest of three
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -6998,18 +7000,18 @@ code = '''
     // try to delete the smallest of three
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7033,18 +7035,18 @@ code = '''
     // try to delete the middle
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7086,21 +7088,21 @@ code = '''
     // try to delete one rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7130,21 +7132,21 @@ code = '''
     // try to delete the other rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7174,27 +7176,27 @@ code = '''
     // try to delete the largest of three
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7236,27 +7238,27 @@ code = '''
     // try to delete the smallest of three
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7298,27 +7300,27 @@ code = '''
     // try to delete the middle
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7388,68 +7390,68 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7549,8 +7551,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -7686,62 +7688,62 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), +1,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
     // this gets a bit messy as we try to make the rbyd take the right shape
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,       0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7829,8 +7831,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -7954,90 +7956,90 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), +1,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
     // this gets a bit messy as we try to make the rbyd take the right shape
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(8), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,      0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(8), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -8161,8 +8163,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -8325,78 +8327,78 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), +1,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(8), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(9), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(9), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(9), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
     // this gets a bit messy as we try to make the rbyd take the right shape
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,      0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,      0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -8514,8 +8516,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -8672,78 +8674,78 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(9), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), +1,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
     // this gets a bit messy as we try to make the rbyd take the right shape
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(8), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(8), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -8861,8 +8863,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -9019,79 +9021,79 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), +1,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
     // this gets a bit messy as we try to make the rbyd take the right shape
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,      0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9197,8 +9199,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -9343,79 +9345,79 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), +1,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), +1,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
     // this gets a bit messy as we try to make the rbyd take the right shape
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,      0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,      0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9521,8 +9523,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -9669,120 +9671,120 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), +1,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
     // this gets a bit messy as we try to make the rbyd take the right shape
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(8), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(11), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(12), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,       0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,       0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(13), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(14), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(9), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(10), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(10), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9930,8 +9932,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -10120,118 +10122,118 @@ code = '''
     //
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(6), +1,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(7), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(8), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(9), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(10), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow to the root
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(10), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(10), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(10), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
     // this gets a bit messy as we try to make the rbyd take the right shape
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(11), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(12), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(13), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(14),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(14),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(14),  0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,      0,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(5), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)),
             // propagate yellow
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(4), 0,
                 LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
 
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -10379,8 +10381,8 @@ code = '''
             &data) => LFS_ERR_NOENT;
 
     // try to recreate
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,    +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -10605,8 +10607,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -10631,8 +10633,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -10651,8 +10653,8 @@ code = '''
 
             // try recreating the rid to make sure things still work
             printf("--- create: %d ---\n", j);
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N);
@@ -10767,14 +10769,14 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
-            // note uattrs have a smaller size to help debugging
+            // note urattrs have a smaller size to help debugging
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                        LFSR_ATTR(
+                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_ATTR(u+1), 0,
                             LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
             }
@@ -10800,8 +10802,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -10833,13 +10835,13 @@ code = '''
 
             // try recreating the rid to make sure things still work
             printf("--- create: %d ---\n", j);
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                        LFSR_ATTR(
+                lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_ATTR(u+1), 0,
                             LFSR_DATA_BUF(names[j % 6], 3)))) => 0;
             }
@@ -10967,8 +10969,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -10993,8 +10995,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
             // try traversing over the tags
@@ -11097,14 +11099,14 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
-            // note uattrs have a smaller size to help debugging
+            // note urattrs have a smaller size to help debugging
             for (unsigned u = 0; u < M; u++) {
-                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                        LFSR_ATTR(
+                lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                        LFSR_RATTR(
                             LFSR_TAG_ATTR(u+1), 0,
                             LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
             }
@@ -11130,8 +11132,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
             // try traversing over the tags
@@ -11202,12 +11204,12 @@ code = '''
     // create and delete one rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11221,16 +11223,16 @@ code = '''
     // create and delete two ids
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11244,17 +11246,17 @@ code = '''
     // create and delete two ids in the other order
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11268,20 +11270,20 @@ code = '''
     // create and delete three ids
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11295,22 +11297,22 @@ code = '''
     // create and delete three ids in the other order
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11342,15 +11344,15 @@ code = '''
     // create and delete one rid
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11364,22 +11366,22 @@ code = '''
     // create and delete two ids
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11393,23 +11395,23 @@ code = '''
     // create and delete two ids in the other order
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11423,29 +11425,29 @@ code = '''
     // create and delete three ids
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11459,31 +11461,31 @@ code = '''
     // create and delete three ids in the other order
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb",         2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG,     +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11537,8 +11539,8 @@ code = '''
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
-        lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_REG, +1,
                     LFSR_DATA_BUF(names[j % 6], 4)))) => 0;
     }
@@ -11589,8 +11591,8 @@ code = '''
             }
 
             lfs_size_t rbyd_weight_before = rbyd.weight;
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == rbyd_weight_before-1);
         }
 
@@ -11602,8 +11604,8 @@ code = '''
                 &data) => LFS_ERR_NOENT;
 
         // try resuming from all tags being removed
-        lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_REG, +1,
                     LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
         assert(rbyd.weight == 1);
@@ -11686,14 +11688,14 @@ code = '''
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
 
     for (unsigned j = 0; j < N; j++) {
-        lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_REG, +1,
                     LFSR_DATA_BUF(names[j % 6], 4)))) => 0;
-        // note uattrs have a smaller size to help debugging
+        // note urattrs have a smaller size to help debugging
         for (unsigned u = 0; u < M; u++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(u+1), 0,
                         LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
         }
@@ -11745,8 +11747,8 @@ code = '''
             }
 
             lfs_size_t rbyd_weight_before = rbyd.weight;
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == rbyd_weight_before-1);
         }
 
@@ -11758,13 +11760,13 @@ code = '''
                 &data) => LFS_ERR_NOENT;
 
         // try resuming from all tags being removed
-        lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_REG, +1,
                     LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
         for (unsigned u = 0; u < M; u++) {
-            lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(u+1), 0,
                         LFSR_DATA_BUF("\xaa\xaa\xaa", 3)))) => 0;
         }
@@ -11879,8 +11881,8 @@ code = '''
             sim[rid] = 'a'+(i % 26);
             count += 1;
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         } else {
@@ -11888,8 +11890,8 @@ code = '''
             memmove(sim+rid, sim+rid+1, count-rid-1);
             count -= 1;
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
         }
     }
 
@@ -11953,8 +11955,8 @@ code = '''
     // make id0 with weight w1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
@@ -11974,8 +11976,8 @@ code = '''
     assert(lfsr_data_size(data_) == 4);
 
     // make id2 with weight w2
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +2,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
@@ -12007,8 +12009,8 @@ code = '''
     assert(lfsr_data_size(data_) == 4);
 
     // make id5 with weight w3
-    lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +3,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
@@ -12052,8 +12054,8 @@ code = '''
     assert(lfsr_data_size(data_) == 4);
 
     // make id9 with weight w4
-    lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +4,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
@@ -12109,8 +12111,8 @@ code = '''
     assert(lfsr_data_size(data_) == 4);
 
     // make id14 with weight w5
-    lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +5,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
@@ -12199,25 +12201,25 @@ code = '''
 
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
             // make id0 with weight w1
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
             // make id2 with weight w2
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +2,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
             // make id5 with weight w3
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +3,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
             // make id9 with weight w4
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +4,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
             // make id14 with weight w5
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +5,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
@@ -12357,8 +12359,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -12447,8 +12449,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -12498,17 +12500,17 @@ code = '''
     // make id0 with weight w1
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("unrelated", 9)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0;
 
@@ -12564,17 +12566,17 @@ code = '''
     assert(lfsr_data_size(data_) == 2);
 
     // make id2 with weight w2
-    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_GROW, +1,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0;
 
@@ -12666,17 +12668,17 @@ code = '''
     assert(lfsr_data_size(data_) == 2);
 
     // make id5 with weight w3
-    lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_GROW, +2,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0;
 
@@ -12804,17 +12806,17 @@ code = '''
     assert(lfsr_data_size(data_) == 2);
 
     // make id9 with weight w4
-    lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xdd\xdd", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_GROW, +3,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xdd\xdd", 2)))) => 0;
 
@@ -12978,17 +12980,17 @@ code = '''
     assert(lfsr_data_size(data_) == 2);
 
     // make id14 with weight w5
-    lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_GROW, +4,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xee\xee", 2)))) => 0;
 
@@ -13209,70 +13211,70 @@ code = '''
 
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(3), 0,
                 LFSR_DATA_BUF("unrelated", 9)),
             // make id0 with weight w1
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xaa\xaa", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xaa\xaa", 2)),
             // make id2 with weight w2
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_GROW, +1,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xbb\xbb", 2)),
             // make id5 with weight w3
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xcc\xcc", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_GROW, +2,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xcc\xcc", 2)),
             // make id9 with weight w4
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xdd\xdd", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_GROW, +3,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xdd\xdd", 2)),
             // make id14 with weight w5
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xee\xee", 2)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_GROW, +4,
                 LFSR_DATA_NULL()),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xee\xee", 2)))) => 0;
 
@@ -13535,8 +13537,8 @@ code = '''
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
         lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(3), 0,
                     LFSR_DATA_BUF("unrelated", 9)))) => 0;
 
@@ -13549,17 +13551,17 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(1), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW, +W-1,
                         LFSR_DATA_NULL()),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(2), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
         }
@@ -13657,8 +13659,8 @@ code = '''
         // test the given permutation with multiple commits
         rbyd = init_rbyd;
         lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-                LFSR_ATTR(
+        lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+                LFSR_RATTR(
                     LFSR_TAG_ATTR(3), 0,
                     LFSR_DATA_BUF("unrelated", 9)))) => 0;
 
@@ -13671,17 +13673,17 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(1), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW, +W-1,
                         LFSR_DATA_NULL()),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(2), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
         }
@@ -13798,8 +13800,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -13824,8 +13826,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == N*W+D);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -13930,8 +13932,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -13956,8 +13958,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW | LFSR_TAG_REG, +D,
                         LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W+D);
@@ -14074,8 +14076,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(2), +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -14100,8 +14102,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW | LFSR_TAG_ATTR(1), +D,
                         LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W+D);
@@ -14231,8 +14233,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -14257,8 +14259,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == N*W-D);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14363,8 +14365,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -14389,8 +14391,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW | LFSR_TAG_REG, -D,
                         LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W-D);
@@ -14507,8 +14509,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(2), +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -14533,8 +14535,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_GROW | LFSR_TAG_ATTR(1), -D,
                         LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W-D);
@@ -14663,8 +14665,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -14689,8 +14691,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == (N-1)*W);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14723,8 +14725,8 @@ code = '''
 
             // try recreating the rid to make sure things still work
             printf("--- create: %d ---\n", j);
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W);
@@ -14760,7 +14762,7 @@ code = '''
     }
 '''
 
-[cases.test_rbyd_sparse_attr_permutations]
+[cases.test_rbyd_sparse_rattr_permutations]
 defines.N = 'range(1, 7)'
 defines.W = 5
 # PERMUTATION=-1 => exhaust all permutations
@@ -14827,8 +14829,8 @@ code = '''
                 }
             }
 
-            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +W,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -14840,7 +14842,7 @@ code = '''
         CFG->read(CFG, rbyd.blocks[0], 0,
                  backup_block, lfsr_rbyd_eoff(&rbyd)) => 0;
 
-        // try appending an attr to each rid, this should not affect
+        // try appending an rattr to each rid, this should not affect
         // weights at all!
         for (unsigned j = 0; j < N; j++) {
             // print what we are appending to help debugging
@@ -14854,8 +14856,8 @@ code = '''
             lfsr_bd_flush(&lfs,
                     NULL, false) => 0;
 
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(1), 0,
                         LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
             assert(rbyd.weight == N*W);
@@ -14885,10 +14887,10 @@ code = '''
                 }
             }
 
-            // now try removing the attr
+            // now try removing the rattr
             printf("--- removing: %d ---\n", j);
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                         LFSR_DATA_NULL()))) => 0;
             assert(rbyd.weight == N*W);
@@ -14913,10 +14915,10 @@ code = '''
                 }
             }
 
-            // and try putting the attr back just for good measure
+            // and try putting the rattr back just for good measure
             printf("--- appending: %d ---\n", j);
-            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(1), 0,
                         LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
             assert(rbyd.weight == N*W);
@@ -14979,11 +14981,11 @@ code = '''
     uint32_t prng = SEED;
     lfs_size_t count = 0;
     for (unsigned i = 0; i < N; i++) {
-        // choose create/delete or attr append/remove
+        // choose create/delete or rattr append/remove
         uint8_t op = TEST_PRNG(&prng) % 4;
         // choose an rid
         lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1);
-        // choose an attr
+        // choose an rattr
         uint8_t u = TEST_PRNG(&prng) % M;
 
         if (rid == (lfs_ssize_t)count || op == 0) {
@@ -15015,11 +15017,11 @@ code = '''
     prng = SEED;
     count = 0;
     for (unsigned i = 0; i < N; i++) {
-        // choose create/delete or attr append/remove
+        // choose create/delete or rattr append/remove
         uint8_t op = TEST_PRNG(&prng) % 4;
         // choose an rid
         lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1);
-        // choose an attr
+        // choose an rattr
         uint8_t u = TEST_PRNG(&prng) % M;
 
         if (rid == (lfs_ssize_t)count || op == 0) {
@@ -15029,8 +15031,8 @@ code = '''
             sim[rid*(M+1)] = 'a'+(i % 26);
             count += 1;
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         } else if (op == 1) {
@@ -15038,14 +15040,14 @@ code = '''
             memmove(sim+rid*(M+1), sim+(rid+1)*(M+1), (count-rid-1)*(M+1));
             count -= 1;
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
         } else if (op == 2) {
             // update our sim
             sim[rid*(M+1) + u+1] = 'a'+(i % 26);
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(u), 0,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
@@ -15053,8 +15055,8 @@ code = '''
             // update our sim
             sim[rid*(M+1) + u+1] = '\0';
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_ATTR(u), 0,
                         LFSR_DATA_NULL()))) => 0;
         }
@@ -15204,8 +15206,8 @@ code = '''
             sim_weights[rid] = weight;
             count += 1;
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +weight,
                         LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         } else if (op == 1) {
@@ -15217,16 +15219,16 @@ code = '''
                     (count-rid-1)*sizeof(lfs_size_t));
             count -= 1;
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()))) => 0;
         } else if (op == 2) {
             // get the correct weight from the sim
             weight_ = sim_weights[rid];
             // update our sim
             sim_weights[rid] += weight;
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_GROW, +weight, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_GROW, +weight, LFSR_DATA_NULL()))) => 0;
         } else if (op == 3) {
             // get the correct weight from the sim
             weight_ = sim_weights[rid];
@@ -15236,8 +15238,8 @@ code = '''
             // update our sim
             sim_weights[rid] -= weight;
             // update our rbyd
-            lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_GROW, -weight, LFSR_DATA_NULL()))) => 0;
+            lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS(
+                    LFSR_RATTR(LFSR_TAG_GROW, -weight, LFSR_DATA_NULL()))) => 0;
         }
     }
 
@@ -15367,18 +15369,18 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
         }
         assert(rbyd.weight == N);
 
-        // test that we can lookup each attr with a wide lookup
+        // test that we can lookup each rattr with a wide lookup
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
@@ -15457,12 +15459,12 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
         }
@@ -15488,8 +15490,8 @@ code = '''
                     NULL, false) => 0;
 
             // remove with a wide tag
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0,
                         LFSR_DATA_NULL()))) => 0;
 
@@ -15601,12 +15603,12 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
         }
@@ -15632,8 +15634,8 @@ code = '''
                     NULL, false) => 0;
 
             // replace with bitwise inverse
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
                             0,
                         LFSR_DATA_BUF(names[j % 6], 3)))) => 0;
@@ -15747,21 +15749,21 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(0x80), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
         }
         assert(rbyd.weight == N);
 
-        // test that we can lookup each attr with a wide lookup
+        // test that we can lookup each rattr with a wide lookup
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
@@ -15840,15 +15842,15 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(0x80), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
         }
@@ -15874,8 +15876,8 @@ code = '''
                     NULL, false) => 0;
 
             // remove with a wide tag
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0,
                         LFSR_DATA_NULL()))) => 0;
 
@@ -15994,15 +15996,15 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR(0x80), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
         }
@@ -16028,8 +16030,8 @@ code = '''
                     NULL, false) => 0;
 
             // replace with bitwise inverse
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
                             0,
                         LFSR_DATA_BUF(names[j % 6], 3)))) => 0;
@@ -16150,15 +16152,15 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N);
 
-        // test that we can lookup each attr with a wide lookup
+        // test that we can lookup each rattr with a wide lookup
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
@@ -16237,9 +16239,9 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -16265,8 +16267,8 @@ code = '''
                     NULL, false) => 0;
 
             // remove with a wide tag
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0,
                         LFSR_DATA_NULL()))) => 0;
 
@@ -16381,9 +16383,9 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
         }
@@ -16409,8 +16411,8 @@ code = '''
                     NULL, false) => 0;
 
             // replace with bitwise inverse
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
                             0,
                         LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
@@ -16518,18 +16520,18 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
         }
         assert(rbyd.weight == N);
 
-        // a supwide attr lookup only gets the file type
+        // a supwide rattr lookup only gets the file type
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         assert(rbyd.weight == N);
 
@@ -16608,12 +16610,12 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
         }
@@ -16639,8 +16641,8 @@ code = '''
                     NULL, false) => 0;
 
             // remove with a wide tag
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_RM | LFSR_TAG_SUP | LFSR_TAG_ATTR, 0,
                         LFSR_DATA_NULL()))) => 0;
 
@@ -16752,12 +16754,12 @@ code = '''
                 }
             }
 
-            // give each attr a subtype based on its rid + SHIFT
-            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
-                    LFSR_ATTR(
+            // give each rattr a subtype based on its rid + SHIFT
+            lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_REG, +1,
                         LFSR_DATA_BUF(names[perm[j] % 6], 4)),
-                    LFSR_ATTR(
+                    LFSR_RATTR(
                         LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0,
                         LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
         }
@@ -16783,8 +16785,8 @@ code = '''
                     NULL, false) => 0;
 
             // replace with bitwise inverse
-            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(
+            lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS(
+                    LFSR_RATTR(
                         LFSR_TAG_SUP | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f),
                             0,
                         LFSR_DATA_BUF(names[j % 6], 3)))) => 0;
@@ -16866,14 +16868,14 @@ code = '''
     // create a null tag hole
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_NULL()))) => 0;
     assert(rbyd.weight == 0);
@@ -16915,24 +16917,24 @@ code = '''
     // create a null tag hole
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_NULL()))) => 0;
     assert(rbyd.weight == 0);
 
     // remove a neighbor to the hole
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_NULL()))) => 0;
     assert(rbyd.weight == 0);
@@ -16974,25 +16976,25 @@ code = '''
     // create a null tag hole
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_NULL()))) => 0;
     assert(rbyd.weight == 2);
 
     // delete a neighbor to the hole
-    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+    lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS(
+            LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
     assert(rbyd.weight == 1);
 
     // can we still access things?
@@ -17032,24 +17034,24 @@ code = '''
     // create a null tag hole
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(0x00), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(0x01), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(0x80), 0,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_NULL()))) => 0;
     assert(rbyd.weight == 0);
 
     // subwide replace a neighbor to the hole
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUB | LFSR_TAG_ATTR(0x02), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     assert(rbyd.weight == 0);
@@ -17100,25 +17102,25 @@ code = '''
     // create a null tag hole
     rbyd = init_rbyd;
     lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_ATTR(1), 0,
                 LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
-            LFSR_ATTR(
+            LFSR_RATTR(
                 LFSR_TAG_REG, +1,
                 LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0,
                 LFSR_DATA_NULL()))) => 0;
     assert(rbyd.weight == 1);
 
     // supwide replace a neighbor to the hole
-    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
-            LFSR_ATTR(
+    lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS(
+            LFSR_RATTR(
                 LFSR_TAG_SUP | LFSR_TAG_ATTR(2), 0,
                 LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     assert(rbyd.weight == 1);