From 88a098c616b1edb4aa40f1fed2bf3ad51e007209 Mon Sep 17 00:00:00 2001
From: Christopher Haster <geky@geky.net>
Date: Sat, 4 May 2024 19:32:36 -0500
Subject: [PATCH] Added lfsr_cat_t to represent concatenated data

So now, instead of one data type trying to do everything, we have two:

1. lfsr_data_t - Readable data, either in-RAM or on-disk

2. lfsr_cat_t - Concatenated data for progging, may be either a simple
   in-RAM buffer or an indirect list of lfsr_data_ts

This comes from an observation that most lfsr_attr_t datas were either
simple buffers, NULL, or required the indirect concatenated datas
anyways (concatendated file fragments). By separating lfsr_cat_t and
lfsr_data_t, maybe we can save RAM in lfsr_attr_t by not needing the
three words necessary for the less-common disk references.

Note the interesting tradeoff:

Simple in-RAM buffers/NULL decrease by 1 word (4 bytes):

  lfsr_data_t            lfsr_cat_t
  .---+---+---+---.      .---+---+---+---.
  |0|    size     |  =>  |0|    size     |
  +---+---+---+---+      +---+---+---+---+
  |      ptr      |      |      ptr      |
  +---+---+---+---+      '---+---+---+---'
  |    (unused)   |
  '---+---+---+---'
  '-------.-------'      '-------.-------'
      12 bytes                8 bytes

While on-disk references increase by 2 words (8 bytes):

  lfsr_data_t            lfsr_cat_t          lfsr_data_t
  .---+---+---+---.      .---+---+---+---.   .---+---+---+---.
  |1|    size     |  =>  |1|    size     | .>|1|    size     |
  +---+---+---+---+      +---+---+---+---+ | +---+---+---+---+
  |     block     |      |      ptr -------' |     block     |
  +---+---+---+---+      '---+---+---+---'   +---+---+---+---+
  |      off      |                          |      off      |
  '---+---+---+---'                          '---+---+---+---'
  '-------.-------'      '-----------------.-----------------'
      12 bytes                         20 bytes

Unless the on-disk references also need concatenation, in which case
this still saves 1 word (4 bytes).

Note I'm not sure this type split is generalizable to other systems. In
littlefs we can't use recursion, so progging concatenated datas already
required two nested functions, and we happen to never need to read
concatenated data, allowing us to completely omit that functionality. In
other systems, where maybe disk-reference attrs are more common, this
tradeoff may not make sense.

Some other things to note:

- We're also losing the inlined-data representation in this change.
  Unfortunately earlier lfsr_data_t measurements showed that this didn't
  really contribute much. It saved RAM in name attrs but added quite a
  bit of complexity to lfsr_data_t operations.

- By separating simple/cat and RAM/disk, we reduce the abused size bits
  from 2-bits down to 1-bit. This doesn't really matter for our current
  31/28-bit littlefs impl, but is nice in that it reenables the
  theoretical 31/31-bit littlefs impl without in-RAM data-structure
  changes.

There are a few temporary hacks that need to be figured out, but this is
already showing code/stack savings. Which is fascinating considering the
new lfsr_cat_* functions and increased temporary allocations:

           code          stack
  before: 33856           2824
  after:  33812 (-0.1%)   2800 (-0.8%)
---
 lfs.c                 |  732 +++++++++---------
 lfs.h                 |   22 +-
 tests/test_btree.toml |  385 +++++-----
 tests/test_mtree.toml |  248 +++---
 tests/test_rbyd.toml  | 1660 ++++++++++++++++++++---------------------
 5 files changed, 1499 insertions(+), 1548 deletions(-)

diff --git a/lfs.c b/lfs.c
index 02abfa5a..5676c532 100644
--- a/lfs.c
+++ b/lfs.c
@@ -1168,14 +1168,7 @@ static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs,
 
 /// lfsr_data_t stuff ///
 
-// the top 2 bits of data's size indicates the actual encoding
-// 0b00 => in-RAM buffer
-// 0b01 => a single leb128
-// 0b10 => on-disk reference
-// 0b11 => concatenated datas
 #define LFSR_DATA_ONDISK 0x80000000
-#define LFSR_DATA_ISIMM  0x40000000
-#define LFSR_DATA_ISCAT  0xc0000000
 
 #define LFSR_DATA_NULL() \
     ((lfsr_data_t){ \
@@ -1193,99 +1186,19 @@ static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs,
         .u.buf.size=_size, \
         .u.buf.buffer=(const void*)(_buffer)})
 
-#define LFSR_DATA_IMM(_buffer, _size) \
-    lfsr_data_fromimm(_buffer, _size)
-
-#define LFSR_DATA_LEB128(_word) \
-    lfsr_data_fromleb128(_word)
-
-// this relies on temporary allocations which is a bit precarious...
-#define LFSR_DATA_CAT(...) \
-    lfsr_data_fromcat( \
-        (const lfsr_data_t[]){__VA_ARGS__}, \
-        sizeof((const lfsr_data_t[]){__VA_ARGS__}) / sizeof(lfsr_data_t))
-
-// These aren't true runtime-typed datas, but allows some special cases to
-// bypass data encoding. External context is required to access these
-// correctly.
-
-// a move of all attrs from an mdir entry 
-#define LFSR_DATA_MOVE(_mdir) \
-    ((lfsr_data_t){.u.buf.buffer=(const void*)(const lfsr_mdir_t*){_mdir}})
-
-// a grm update, note this is mutable! we may update the grm during
-// mdir commits
-#define LFSR_DATA_GRM(_grm) \
-    ((lfsr_data_t){.u.buf.buffer=(const void*)(lfsr_grm_t*){_grm}})
-
-// writing to an unrelated trunk in the rbyd
-typedef struct lfsr_shrubcommit lfsr_shrubcommit_t;
-
-#define LFSR_DATA_SHRUBCOMMIT(_shrub, _rid, _attrs, _attr_count) \
-    ((lfsr_data_t){.u.buf.buffer=(const void*)&(const lfsr_shrubcommit_t){ \
-        .shrub=_shrub, \
-        .rid=_rid, \
-        .attrs=_attrs, \
-        .attr_count=_attr_count}})
-
-#define LFSR_DATA_SHRUBTRUNK(_shrub) \
-    ((lfsr_data_t){.u.buf.buffer=(const void*)(const lfsr_shrub_t*){_shrub}})
-
+// data helpers
 static inline bool lfsr_data_ondisk(lfsr_data_t data) {
-    return (data.u.size & LFSR_DATA_ISCAT) == LFSR_DATA_ONDISK;
+    return data.u.size & LFSR_DATA_ONDISK;
 }
 
 static inline bool lfsr_data_isbuf(lfsr_data_t data) {
-    return (data.u.size & LFSR_DATA_ISCAT) == 0;
-}
-
-static inline bool lfsr_data_isimm(lfsr_data_t data) {
-    return (data.u.size & LFSR_DATA_ISCAT) == LFSR_DATA_ISIMM;
-}
-
-static inline bool lfsr_data_iscat(lfsr_data_t data) {
-    return (data.u.size & LFSR_DATA_ISCAT) == LFSR_DATA_ISCAT;
+    return !(data.u.size & LFSR_DATA_ONDISK);
 }
 
 static inline lfs_size_t lfsr_data_size(lfsr_data_t data) {
-    return data.u.size & ~LFSR_DATA_ISCAT;
+    return data.u.size & ~LFSR_DATA_ONDISK;
 }
 
-// some data initializers just can't be macros, we at least make these inline
-// so most of the internal logic is hopefully elided
-static inline lfsr_data_t lfsr_data_fromimm(
-        const void *buffer, lfs_size_t size) {
-    LFS_ASSERT(size <= 8);
-
-    lfsr_data_t data;
-    memcpy(data.u.imm.buf, buffer, size);
-    data.u.imm.size = LFSR_DATA_ISIMM | size;
-    return data;
-}
-
-static inline lfsr_data_t lfsr_data_fromleb128(uint32_t word) {
-    lfsr_data_t data;
-    lfs_ssize_t size = lfs_toleb128(word, data.u.imm.buf, 5);
-    LFS_ASSERT(size > 0);
-    LFS_ASSERT(size <= 5);
-    data.u.imm.size = LFSR_DATA_ISIMM | size;
-    return data;
-}
-
-static inline lfsr_data_t lfsr_data_fromcat(
-        const lfsr_data_t *datas, lfs_size_t count) {
-    // find total size
-    lfs_size_t size = 0;
-    for (uint8_t i = 0; i < count; i++) {
-        size += lfsr_data_size(datas[i]);
-    }
-
-    return (lfsr_data_t){
-            .u.cat.size=LFSR_DATA_ISCAT | size,
-            .u.cat.datas=datas};
-}
-
-// note these operations only work on "simple" (not concatenated) datas
 static lfsr_data_t lfsr_data_slice(lfsr_data_t data,
         lfs_ssize_t off, lfs_ssize_t size) {
     // limit our off/size to data range, note the use of unsigned casts
@@ -1297,26 +1210,15 @@ static lfsr_data_t lfsr_data_slice(lfsr_data_t data,
             (lfs_size_t)size,
             lfsr_data_size(data) - off_);
 
-    // on-disk? increment
+    // on-disk?
     if (lfsr_data_ondisk(data)) {
         data.u.disk.off += off_;
         data.u.disk.size = LFSR_DATA_ONDISK | size_;
 
-    // buffer? increment
-    } else if (lfsr_data_isbuf(data)) {
+    // buffer?
+    } else {
         data.u.buf.buffer += off_;
         data.u.buf.size = size_;
-
-    // inlined? internal memmove
-    } else if (lfsr_data_isimm(data)) {
-        memmove(data.u.imm.buf,
-                data.u.imm.buf + off_,
-                size_);
-        data.u.imm.size = LFSR_DATA_ISIMM | size_;
-
-    // concatenated? not supported
-    } else {
-        LFS_UNREACHABLE();
     }
 
     return data;
@@ -1357,16 +1259,8 @@ static lfs_ssize_t lfsr_data_read(lfs_t *lfs, lfsr_data_t *data,
         }
 
     // buffer?
-    } else if (lfsr_data_isbuf(*data)) {
-        memcpy(buffer, data->u.buf.buffer, d);
-
-    // inlined?
-    } else if (lfsr_data_isimm(*data)) {
-        memcpy(buffer, data->u.imm.buf, d);
-
-    // concatenated? not supported
     } else {
-        LFS_UNREACHABLE();
+        memcpy(buffer, data->u.buf.buffer, d);
     }
 
     *data = lfsr_data_slice(*data, d, -1);
@@ -1450,26 +1344,13 @@ static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs, lfsr_data_t data,
         }
 
     // buffer?
-    } else if (lfsr_data_isbuf(data)) {
+    } else {
         int cmp = memcmp(data.u.buf.buffer, buffer, d);
         if (cmp < 0) {
             return LFS_CMP_LT;
         } else if (cmp > 0) {
             return LFS_CMP_GT;
         }
-
-    // inlined?
-    } else if (lfsr_data_isimm(data)) {
-        int cmp = memcmp(data.u.imm.buf, buffer, d);
-        if (cmp < 0) {
-            return LFS_CMP_LT;
-        } else if (cmp > 0) {
-            return LFS_CMP_GT;
-        }
-
-    // concatenated? not supported
-    } else {
-        LFS_UNREACHABLE();
     }
 
     // if data is equal, check for size mismatch
@@ -1502,7 +1383,7 @@ static lfs_scmp_t lfsr_data_namecmp(lfs_t *lfs, lfsr_data_t data,
     return lfsr_data_cmp(lfs, data, name, name_size);
 }
 
-static int lfsr_bd_progdata_(lfs_t *lfs,
+static int lfsr_bd_progdata(lfs_t *lfs,
         lfs_block_t block, lfs_size_t off, lfsr_data_t data,
         uint32_t *cksum_) {
     // on-disk?
@@ -1516,53 +1397,156 @@ static int lfsr_bd_progdata_(lfs_t *lfs,
         }
 
     // buffer?
-    } else if (lfsr_data_isbuf(data)) {
+    } else {
         int err = lfsr_bd_prog(lfs, block, off,
                 data.u.buf.buffer, data.u.buf.size,
                 cksum_);
         if (err) {
             return err;
         }
-
-    // inlined?
-    } else if (lfsr_data_isimm(data)) {
-        int err = lfsr_bd_prog(lfs, block, off,
-                data.u.imm.buf, lfsr_data_size(data),
-                cksum_);
-        if (err) {
-            return err;
-        }
-
-    // concatenated? nesting would require recursion
-    } else {
-        LFS_UNREACHABLE();
     }
 
     return 0;
 }
 
-static int lfsr_bd_progdata(lfs_t *lfs,
-        lfs_block_t block, lfs_size_t off, lfsr_data_t data,
+
+// concatenated data
+
+typedef struct lfsr_cat {
+    // sign(size)=0 => single in-RAM buffer
+    // sign(size)=1 => multiple concatenated datas
+    union {
+        lfs_size_t size;
+        struct {
+            lfs_size_t size;
+            const uint8_t *buffer;
+        } buf;
+        struct {
+            lfs_size_t size;
+            const lfsr_data_t *datas;
+        } cat;
+    } u;
+} lfsr_cat_t;
+
+#define LFSR_CAT_ISCAT 0x80000000
+
+#define LFSR_CAT_NULL() \
+    ((lfsr_cat_t){ \
+        .u.buf.size=0, \
+        .u.buf.buffer=NULL})
+
+#define LFSR_CAT_BUF(_buffer, _size) \
+    ((lfsr_cat_t){ \
+        .u.buf.size=_size, \
+        .u.buf.buffer=(const void*)(_buffer)})
+
+#define LFSR_CAT_DATA(_data) \
+    lfsr_cat_fromdatas(_data, 1)
+
+#define LFSR_CAT_DATAS(_datas, _count) \
+    lfsr_cat_fromdatas(_datas, _count)
+
+#define LFSR_CAT_CAT(...) \
+    lfsr_cat_fromdatas( \
+        (const lfsr_data_t[]){__VA_ARGS__}, \
+        sizeof((const lfsr_data_t[]){__VA_ARGS__}) / sizeof(lfsr_data_t))
+
+// cat helpers
+static inline bool lfsr_cat_isbuf(lfsr_cat_t cat) {
+    return !(cat.u.size & LFSR_CAT_ISCAT);
+}
+
+static inline bool lfsr_cat_iscat(lfsr_cat_t cat) {
+    return cat.u.size & LFSR_CAT_ISCAT;
+}
+
+static inline lfs_size_t lfsr_cat_size(lfsr_cat_t cat) {
+    return cat.u.size & ~LFSR_CAT_ISCAT;
+}
+
+static inline lfsr_data_t lfsr_cat_data(lfsr_cat_t cat) {
+    // this only works if cat is a simple buffer
+    LFS_ASSERT(lfsr_cat_isbuf(cat));
+    return LFSR_DATA_BUF(cat.u.buf.buffer, cat.u.buf.size);
+}
+
+// some initializers just can't be macros, we at least make these inline
+// so most of the internal logic is hopefully elided
+static inline lfsr_cat_t lfsr_cat_fromdatas(
+        const lfsr_data_t *datas, lfs_size_t count) {
+    // find total size, we store this instead of count
+    lfs_size_t size = 0;
+    for (uint8_t i = 0; i < count; i++) {
+        size += lfsr_data_size(datas[i]);
+    }
+
+    return (lfsr_cat_t){
+            .u.cat.size=LFSR_CAT_ISCAT | size,
+            .u.cat.datas=datas};
+}
+
+// some more cats
+#define LFSR_LEB128_DSIZE  5
+#define LFSR_LLEB128_DSIZE 4
+
+#define LFSR_CAT_LEB128(_word) \
+    lfsr_cat_fromleb128(_word, (uint8_t[LFSR_LEB128_DSIZE]){0})
+
+#define LFSR_CAT_LLEB128(_word) \
+    lfsr_cat_fromlleb128(_word, (uint8_t[LFSR_LLEB128_DSIZE]){0})
+
+static inline lfsr_cat_t lfsr_cat_fromleb128(uint32_t word,
+        uint8_t buffer[static LFSR_LEB128_DSIZE]) {
+    // leb128s should not exceed 31-bits
+    LFS_ASSERT(word <= 0x7fffffff);
+
+    lfs_ssize_t d = lfs_toleb128(word, buffer, LFSR_LEB128_DSIZE);
+    LFS_ASSERT(d >= 0);
+    return LFSR_CAT_BUF(buffer, d);
+}
+
+static inline lfsr_cat_t lfsr_cat_fromlleb128(uint32_t word,
+        uint8_t buffer[static LFSR_LLEB128_DSIZE]) {
+    // little-leb128s should not exceed 28-bits
+    LFS_ASSERT(word <= 0x0fffffff);
+
+    lfs_ssize_t d = lfs_toleb128(word, buffer, LFSR_LLEB128_DSIZE);
+    LFS_ASSERT(d >= 0);
+    return LFSR_CAT_BUF(buffer, d);
+}
+
+#define LFSR_CAT_NAME(_did, _name, _name_size) \
+    LFSR_CAT_CAT( \
+        lfsr_cat_data(LFSR_CAT_LEB128(_did)), \
+        LFSR_DATA_BUF(_name, _name_size))
+
+// cat <-> bd interactions
+//
+// these are simpler than data interactions because we only ever prog
+// concatenated data
+
+static int lfsr_bd_progcat(lfs_t *lfs,
+        lfs_block_t block, lfs_size_t off, lfsr_cat_t cat,
         uint32_t *cksum_) {
-    // simple data?
-    if (!lfsr_data_iscat(data)) {
-        return lfsr_bd_progdata_(lfs, block, off, data,
+    // direct buffer?
+    if (lfsr_cat_isbuf(cat)) {
+        return lfsr_bd_progdata(lfs, block, off, lfsr_cat_data(cat),
                 cksum_);
 
-    // concatenated data? handle specially to avoid recursion
+    // indirect concatenated data?
     } else {
-        lfs_size_t size = lfsr_data_size(data);
-        const lfsr_data_t *datas = data.u.cat.datas;
+        lfs_size_t size = lfsr_cat_size(cat);
+        const lfsr_data_t *data = cat.u.cat.datas;
         while (size > 0) {
-            int err = lfsr_bd_progdata_(lfs, block, off, *datas,
+            int err = lfsr_bd_progdata(lfs, block, off, *data,
                     cksum_);
             if (err) {
                 return err;
             }
 
-            off += lfsr_data_size(*datas);
-            size -= lfsr_data_size(*datas);
-            datas += 1;
+            off += lfsr_data_size(*data);
+            size -= lfsr_data_size(*data);
+            data += 1;
         }
 
         return 0;
@@ -1570,39 +1554,57 @@ static int lfsr_bd_progdata(lfs_t *lfs,
 }
 
 
-
-
 // operations on attribute lists
 
-//struct lfs_mattr {
-//    lfs_tag_t tag;
-//    const void *buffer;
-//};
-//
-//struct lfs_diskoff {
-//    lfs_block_t block;
-//    lfs_off_t off;
-//};
-//
-//#define LFS_MKATTRS(...) 
-//    (struct lfs_mattr[]){__VA_ARGS__}, 
-//    sizeof((struct lfs_mattr[]){__VA_ARGS__}) / sizeof(struct lfs_mattr)
-
 typedef struct lfsr_attr {
     lfsr_tag_t tag;
     lfsr_srid_t delta;
-    lfsr_data_t data;
+    lfsr_cat_t cat;
 } lfsr_attr_t;
 
-#define LFSR_ATTR(_tag, _delta, _data) \
-    ((const lfsr_attr_t){_tag, _delta, _data})
+#define LFSR_ATTR(_tag, _delta, _cat) \
+    ((const lfsr_attr_t){_tag, _delta, _cat})
 
-#define LFSR_ATTR_NOOP() LFSR_ATTR(LFSR_TAG_NULL, 0, LFSR_DATA_NULL())
+#define LFSR_ATTR_NOOP() LFSR_ATTR(LFSR_TAG_NULL, 0, LFSR_CAT_NULL())
 
+// create an attribute list
 #define LFSR_ATTRS(...) \
     (const lfsr_attr_t[]){__VA_ARGS__}, \
     sizeof((const lfsr_attr_t[]){__VA_ARGS__}) / sizeof(lfsr_attr_t)
 
+// attr hacks - sometimes we want to marshal something that isn't really data
+
+// a move of all attrs from an mdir entry
+#define LFSR_ATTR_MOVE(_tag, _delta, _mdir) \
+    ((const lfsr_attr_t){ \
+        _tag, _delta, \
+        .cat.u.buf.buffer=(const void*)(const lfsr_mdir_t*){_mdir}})
+
+// a grm update, note this is mutable! we may update the grm during
+// mdir commits
+#define LFSR_ATTR_GRM(_tag, _delta, _grm) \
+    ((const lfsr_attr_t){ \
+        _tag, _delta, \
+        .cat.u.buf.buffer=(const void*)(lfsr_grm_t*){_grm}})
+
+// writing to an unrelated trunk in the rbyd
+typedef struct lfsr_shrubcommit lfsr_shrubcommit_t;
+
+#define LFSR_ATTR_SHRUBCOMMIT(_tag, _delta, \
+        _shrub, _rid, _attrs, _attr_count) \
+    ((const lfsr_attr_t){ \
+        _tag, _delta, \
+        .cat.u.buf.buffer=(const void*)&(const lfsr_shrubcommit_t){ \
+            .shrub=_shrub, \
+            .rid=_rid, \
+            .attrs=_attrs, \
+            .attr_count=_attr_count}})
+
+#define LFSR_ATTR_SHRUBTRUNK(_tag, _delta, _shrub) \
+    ((const lfsr_attr_t){ \
+        _tag, _delta, \
+        .cat.u.buf.buffer=(const void*)(const lfsr_shrub_t*){_shrub}})
+
 // some helpers
 static inline bool lfsr_attr_isnoop(const lfsr_attr_t *attr) {
     return !attr->tag && attr->delta == 0;
@@ -1613,20 +1615,20 @@ static inline bool lfsr_attr_isinsert(const lfsr_attr_t *attr) {
 }
 
 static inline lfsr_grm_t *lfsr_attr_grm(const lfsr_attr_t *attr) {
-    return (lfsr_grm_t*)attr->data.u.buf.buffer;
+    return (lfsr_grm_t*)attr->cat.u.buf.buffer;
 }
 
 static inline lfsr_mdir_t *lfsr_attr_mdir(const lfsr_attr_t *attr) {
-    return (lfsr_mdir_t*)attr->data.u.buf.buffer;
+    return (lfsr_mdir_t*)attr->cat.u.buf.buffer;
 }
 
 static inline const lfsr_shrubcommit_t *lfsr_attr_shrubcommit(
         const lfsr_attr_t *attr) {
-    return (const lfsr_shrubcommit_t*)attr->data.u.buf.buffer;
+    return (const lfsr_shrubcommit_t*)attr->cat.u.buf.buffer;
 }
 
 static inline lfsr_shrub_t *lfsr_attr_shrubtrunk(const lfsr_attr_t *attr) {
-    return (lfsr_shrub_t*)attr->data.u.buf.buffer;
+    return (lfsr_shrub_t*)attr->cat.u.buf.buffer;
 }
 
 
@@ -1772,10 +1774,10 @@ typedef struct lfsr_ecksum {
 //
 #define LFSR_ECKSUM_DSIZE (4+4)
 
-#define LFSR_DATA_FROMECKSUM(_ecksum) \
-    lfsr_data_fromecksum(_ecksum, (uint8_t[LFSR_ECKSUM_DSIZE]){0})
+#define LFSR_CAT_ECKSUM(_ecksum) \
+    lfsr_cat_fromecksum(_ecksum, (uint8_t[LFSR_ECKSUM_DSIZE]){0})
 
-static lfsr_data_t lfsr_data_fromecksum(const lfsr_ecksum_t *ecksum,
+static lfsr_cat_t lfsr_cat_fromecksum(const lfsr_ecksum_t *ecksum,
         uint8_t buffer[static LFSR_ECKSUM_DSIZE]) {
     // you shouldn't try to encode a not-ecksum, that doesn't make sense
     LFS_ASSERT(ecksum->cksize != -1);
@@ -1790,7 +1792,7 @@ static lfsr_data_t lfsr_data_fromecksum(const lfsr_ecksum_t *ecksum,
     lfs_tole32_(ecksum->cksum, &buffer[d]);
     d += 4;
 
-    return LFSR_DATA_BUF(buffer, d);
+    return LFSR_CAT_BUF(buffer, d);
 }
 
 static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data,
@@ -1826,10 +1828,10 @@ static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data,
 //
 #define LFSR_BPTR_DSIZE (4+5+4+4+4)
 
-#define LFSR_DATA_FROMBPTR(_bptr) \
-    lfsr_data_frombptr(_bptr, (uint8_t[LFSR_BPTR_DSIZE]){0})
+#define LFSR_CAT_BPTR(_bptr) \
+    lfsr_cat_frombptr(_bptr, (uint8_t[LFSR_BPTR_DSIZE]){0})
 
-static lfsr_data_t lfsr_data_frombptr(const lfsr_bptr_t *bptr,
+static lfsr_cat_t lfsr_cat_frombptr(const lfsr_bptr_t *bptr,
         uint8_t buffer[static LFSR_BPTR_DSIZE]) {
     // size should not exceed 28-bits
     LFS_ASSERT(lfsr_data_size(bptr->data) <= 0x0fffffff);
@@ -1862,7 +1864,7 @@ static lfsr_data_t lfsr_data_frombptr(const lfsr_bptr_t *bptr,
     lfs_tole32_(bptr->cksum, &buffer[d]);
     d += 4;
 
-    return LFSR_DATA_BUF(buffer, d);
+    return LFSR_CAT_BUF(buffer, d);
 }
 
 static int lfsr_data_readbptr(lfs_t *lfs, lfsr_data_t *data,
@@ -2035,10 +2037,10 @@ static inline bool lfsr_grm_isrm(const lfsr_grm_t *grm, lfsr_smid_t mid) {
     return grm->rms[0] == mid || grm->rms[1] == mid;
 }
 
-#define LFSR_DATA_FROMGRM(_grm) \
-    lfsr_data_fromgrm(_grm, (uint8_t[LFSR_GRM_DSIZE]){0})
+#define LFSR_CAT_GRM(_grm) \
+    lfsr_cat_fromgrm(_grm, (uint8_t[LFSR_GRM_DSIZE]){0})
 
-static lfsr_data_t lfsr_data_fromgrm(const lfsr_grm_t *grm,
+static lfsr_cat_t lfsr_cat_fromgrm(const lfsr_grm_t *grm,
         uint8_t buffer[static LFSR_GRM_DSIZE]) {
     // make sure to zero so we don't leak any info
     memset(buffer, 0, LFSR_GRM_DSIZE);
@@ -2056,7 +2058,7 @@ static lfsr_data_t lfsr_data_fromgrm(const lfsr_grm_t *grm,
         d += d_;
     }
 
-    return LFSR_DATA_BUF(buffer, lfsr_gdelta_size(buffer, LFSR_GRM_DSIZE));
+    return LFSR_CAT_BUF(buffer, lfsr_gdelta_size(buffer, LFSR_GRM_DSIZE));
 }
 
 static inline void lfsr_gdelta_xorgrm(lfs_t *lfs,
@@ -2064,9 +2066,10 @@ static inline void lfsr_gdelta_xorgrm(lfs_t *lfs,
         const lfsr_grm_t *grm) {
     LFS_ASSERT(size >= LFSR_GRM_DSIZE);
 
+    // TODO should gdelta be handled differently?
     uint8_t buf[LFSR_GRM_DSIZE];
     int err = lfsr_gdelta_xor(lfs, gdelta, size,
-            lfsr_data_fromgrm(grm, buf));
+            lfsr_cat_data(lfsr_cat_fromgrm(grm, buf)));
     LFS_ASSERT(!err);
 }
 
@@ -2674,11 +2677,11 @@ static int lfsr_rbyd_appendtag(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     return 0;
 }
 
-static int lfsr_rbyd_appenddata(lfs_t *lfs, lfsr_rbyd_t *rbyd,
-        lfsr_data_t data) {
+static int lfsr_rbyd_appendcat(lfs_t *lfs, lfsr_rbyd_t *rbyd,
+        lfsr_cat_t cat) {
     uint32_t cksum_ = rbyd->cksum;
-    int err = lfsr_bd_progdata(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd),
-            data,
+    int err = lfsr_bd_progcat(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd),
+            cat,
             &cksum_);
     if (err) {
         return err;
@@ -2688,20 +2691,20 @@ static int lfsr_rbyd_appenddata(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     rbyd->eoff
             += ((lfs_size_t)lfs_parity(rbyd->cksum ^ cksum_)
                 << (8*sizeof(lfs_size_t)-1))
-            + lfsr_data_size(data);
+            + lfsr_cat_size(cat);
     rbyd->cksum = cksum_;
     return 0;
 }
 
 static int lfsr_rbyd_appendattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd,
-        lfsr_tag_t tag, lfsr_rid_t weight, lfsr_data_t data) {
+        lfsr_tag_t tag, lfsr_rid_t weight, lfsr_cat_t cat) {
     int err = lfsr_rbyd_appendtag(lfs, rbyd,
-            tag, weight, lfsr_data_size(data));
+            tag, weight, lfsr_cat_size(cat));
     if (err) {
         return err;
     }
 
-    err = lfsr_rbyd_appenddata(lfs, rbyd, data);
+    err = lfsr_rbyd_appendcat(lfs, rbyd, cat);
     if (err) {
         return err;
     }
@@ -2831,7 +2834,7 @@ 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_tag_t tag, lfsr_srid_t delta, lfsr_data_t data) {
+        lfsr_srid_t rid, lfsr_tag_t tag, lfsr_srid_t delta, lfsr_cat_t cat) {
     // must fetch before mutating!
     LFS_ASSERT(lfsr_rbyd_isfetched(rbyd));
     // tag must not be internal at this point
@@ -3292,7 +3295,7 @@ trunk:;
                             (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0)
                                 | LFSR_TAG_NULL,
                             0,
-                            LFSR_DATA_NULL());
+                            LFSR_CAT_NULL());
                     if (err) {
                         return err;
                     }
@@ -3407,7 +3410,7 @@ leaf:;
                     ? LFSR_TAG_NULL
                     : lfsr_tag_key(tag)),
             upper_rid - lower_rid + delta,
-            data);
+            cat);
     if (err) {
         return err;
     }
@@ -3483,7 +3486,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
         }
 
         err = lfsr_rbyd_appendattr_(lfs, rbyd,
-                LFSR_TAG_ECKSUM, 0, LFSR_DATA_FROMECKSUM(&ecksum));
+                LFSR_TAG_ECKSUM, 0, LFSR_CAT_ECKSUM(&ecksum));
         if (err) {
             return err;
         }
@@ -3571,7 +3574,7 @@ static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd,
                 && (lfs_size_t)(rid + 1) <= (lfs_size_t)end_rid) {
             int err = lfsr_rbyd_appendattr(lfs, rbyd,
                     rid - lfs_smax32(start_rid, 0),
-                    attrs[i].tag, attrs[i].delta, attrs[i].data);
+                    attrs[i].tag, attrs[i].delta, attrs[i].cat);
             if (err) {
                 return err;
             }
@@ -3701,7 +3704,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
 //
 // also note the direct use of weight instead of delta here
 static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
-        lfsr_tag_t tag, lfsr_rid_t weight, lfsr_data_t data) {
+        lfsr_tag_t tag, lfsr_rid_t weight, lfsr_cat_t cat) {
     // begin appending
     int err = lfsr_rbyd_prepareappend(lfs, rbyd);
     if (err) {
@@ -3712,7 +3715,7 @@ static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
     err = lfsr_rbyd_appendattr_(lfs, rbyd,
             (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | tag,
             weight,
-            data);
+            cat);
     if (err) {
         return err;
     }
@@ -3745,7 +3748,8 @@ static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
         }
 
         // write the tag
-        err = lfsr_rbyd_appendcompactattr(lfs, rbyd_, tag, weight, data);
+        err = lfsr_rbyd_appendcompactattr(lfs, rbyd_,
+                tag, weight, LFSR_CAT_DATA(&data));
         if (err) {
             return err;
         }
@@ -3933,7 +3937,7 @@ static int lfsr_rbyd_appendgdelta(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
                 (size == 0)
                     ? LFSR_TAG_RM | LFSR_TAG_GRMDELTA
                     : LFSR_TAG_GRMDELTA, 0,
-                LFSR_DATA_BUF(grm_, size));
+                LFSR_CAT_BUF(grm_, size));
         if (err) {
             return err;
         }
@@ -4101,10 +4105,10 @@ static inline int lfsr_btree_cmp(
 //
 #define LFSR_BRANCH_DSIZE (5+4+4)
 
-#define LFSR_DATA_FROMBRANCH(_branch) \
-    lfsr_data_frombranch(_branch, (uint8_t[LFSR_BRANCH_DSIZE]){0})
+#define LFSR_CAT_BRANCH(_branch) \
+    lfsr_cat_frombranch(_branch, (uint8_t[LFSR_BRANCH_DSIZE]){0})
 
-static lfsr_data_t lfsr_data_frombranch(const lfsr_rbyd_t *branch,
+static lfsr_cat_t lfsr_cat_frombranch(const lfsr_rbyd_t *branch,
         uint8_t buffer[static LFSR_BRANCH_DSIZE]) {
     // block should not exceed 31-bits
     LFS_ASSERT(branch->blocks[0] <= 0x7fffffff);
@@ -4123,7 +4127,7 @@ static lfsr_data_t lfsr_data_frombranch(const lfsr_rbyd_t *branch,
     lfs_tole32_(branch->cksum, &buffer[d]);
     d += 4;
 
-    return LFSR_DATA_BUF(buffer, d);
+    return LFSR_CAT_BUF(buffer, d);
 }
 
 static int lfsr_data_readbranch(lfs_t *lfs, lfsr_data_t *data,
@@ -4171,10 +4175,10 @@ static int lfsr_data_readbranch(lfs_t *lfs, lfsr_data_t *data,
 //
 #define LFSR_BTREE_DSIZE (5+LFSR_BRANCH_DSIZE)
 
-#define LFSR_DATA_FROMBTREE(_btree) \
-    lfsr_data_frombtree(_btree, (uint8_t[LFSR_BTREE_DSIZE]){0})
+#define LFSR_CAT_BTREE(_btree) \
+    lfsr_cat_frombtree(_btree, (uint8_t[LFSR_BTREE_DSIZE]){0})
 
-static lfsr_data_t lfsr_data_frombtree(const lfsr_btree_t *btree,
+static lfsr_cat_t lfsr_cat_frombtree(const lfsr_btree_t *btree,
         uint8_t buffer[static LFSR_BTREE_DSIZE]) {
     // weight should not exceed 31-bits
     LFS_ASSERT(btree->weight <= 0x7fffffff);
@@ -4184,10 +4188,10 @@ static lfsr_data_t lfsr_data_frombtree(const lfsr_btree_t *btree,
     LFS_ASSERT(d_ >= 0);
     d += d_;
 
-    lfsr_data_t data = lfsr_data_frombranch(btree, &buffer[d]);
-    d += lfsr_data_size(data);
+    lfsr_cat_t cat = lfsr_cat_frombranch(btree, &buffer[d]);
+    d += lfsr_cat_size(cat);
 
-    return LFSR_DATA_BUF(buffer, d);
+    return LFSR_CAT_BUF(buffer, d);
 }
 
 static int lfsr_data_readbtree(lfs_t *lfs, lfsr_data_t *data,
@@ -4379,7 +4383,9 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree,
 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_attr_t attrs__[static 4],
-        uint8_t buf__[static 2*LFSR_BRANCH_DSIZE]) {
+        uint8_t buf__[static 2*LFSR_BRANCH_DSIZE],
+        // TODO can we carve this out of buf__?
+        lfsr_data_t split_data__[static 1]) {
     lfsr_bid_t bid = *bid_;
     LFS_ASSERT(bid <= (lfsr_bid_t)btree->weight);
     const lfsr_attr_t *attrs = *attrs_;
@@ -4504,16 +4510,16 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         bid -= pid - (rbyd.weight-1);
         if (rbyd_.weight == 0) {
             attrs__[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_RM, -rbyd.weight, LFSR_DATA_NULL());
+                    LFSR_TAG_RM, -rbyd.weight, LFSR_CAT_NULL());
         } else {
             attrs__[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_BRANCH, 0,
-                    lfsr_data_frombranch(&rbyd_, &buf__[buf_size]));
+                    lfsr_cat_frombranch(&rbyd_, &buf__[buf_size]));
             buf_size += LFSR_BRANCH_DSIZE;
             if (rbyd_.weight != rbyd.weight) {
                 attrs__[attr_count++] = LFSR_ATTR(
                         LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight,
-                        LFSR_DATA_NULL());
+                        LFSR_CAT_NULL());
             }
         }
         attrs = attrs__;
@@ -4761,9 +4767,8 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         // note we need to do this after playing out pending attrs in case
         // they introduce a new name!
         lfsr_tag_t split_tag;
-        lfsr_data_t split_data;
         err = lfsr_rbyd_lookupnext(lfs, &sibling, 0, LFSR_TAG_NAME,
-                NULL, &split_tag, NULL, &split_data);
+                NULL, &split_tag, NULL, &split_data__[0]);
         if (err) {
             LFS_ASSERT(err != LFS_ERR_NOENT);
             return err;
@@ -4778,35 +4783,37 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         if (!lfsr_rbyd_trunk(&parent)) {
             attrs__[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_BRANCH, +rbyd_.weight,
-                    lfsr_data_frombranch(&rbyd_, &buf__[buf_size]));
+                    lfsr_cat_frombranch(&rbyd_, &buf__[buf_size]));
             buf_size += LFSR_BRANCH_DSIZE;
             attrs__[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_BRANCH, +sibling.weight,
-                    lfsr_data_frombranch(&sibling, &buf__[buf_size]));
+                    lfsr_cat_frombranch(&sibling, &buf__[buf_size]));
             buf_size += LFSR_BRANCH_DSIZE;
             if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) {
                 attrs__[attr_count++] = LFSR_ATTR(
-                        LFSR_TAG_NAME, 0, split_data);
+                        LFSR_TAG_NAME, 0,
+                        lfsr_cat_fromdatas(&split_data__[0], 1));
             }
         // split root?
         } else {
             bid -= pid - (rbyd.weight-1);
             attrs__[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_BRANCH, 0,
-                    lfsr_data_frombranch(&rbyd_, &buf__[buf_size]));
+                    lfsr_cat_frombranch(&rbyd_, &buf__[buf_size]));
             buf_size += LFSR_BRANCH_DSIZE;
             if (rbyd_.weight != rbyd.weight) {
                 attrs__[attr_count++] = LFSR_ATTR(
                         LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight,
-                        LFSR_DATA_NULL());
+                        LFSR_CAT_NULL());
             }
             attrs__[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_BRANCH, +sibling.weight,
-                    lfsr_data_frombranch(&sibling, &buf__[buf_size]));
+                    lfsr_cat_frombranch(&sibling, &buf__[buf_size]));
             buf_size += LFSR_BRANCH_DSIZE;
             if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) {
                 attrs__[attr_count++] = LFSR_ATTR(
-                        LFSR_TAG_NAME, 0, split_data);
+                        LFSR_TAG_NAME, 0,
+                        lfsr_cat_fromdatas(&split_data__[0], 1));
             }
         }
         attrs = attrs__;
@@ -4872,15 +4879,15 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree,
         buf_size = 0;
         bid -= pid - (rbyd.weight-1);
         attrs__[attr_count++] = LFSR_ATTR(
-                LFSR_TAG_RM, -sibling.weight, LFSR_DATA_NULL());
+                LFSR_TAG_RM, -sibling.weight, LFSR_CAT_NULL());
         attrs__[attr_count++] = LFSR_ATTR(
                 LFSR_TAG_BRANCH, 0,
-                lfsr_data_frombranch(&rbyd_, &buf__[buf_size]));
+                lfsr_cat_frombranch(&rbyd_, &buf__[buf_size]));
         buf_size += LFSR_BRANCH_DSIZE;
         if (rbyd_.weight != rbyd.weight) {
             attrs__[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight,
-                    LFSR_DATA_NULL());
+                    LFSR_CAT_NULL());
         }
         attrs = attrs__;
 
@@ -4896,11 +4903,12 @@ static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree,
     // we need some scratch space for tail-recursive attrs
     lfsr_attr_t attrs__[4];
     uint8_t buffer[2*LFSR_BRANCH_DSIZE];
+    lfsr_data_t split_data__[1];
 
     // try to commit to the btree
     int err = lfsr_btree_commit_(lfs, btree,
             &bid, &attrs, &attr_count,
-            attrs__, buffer);
+            attrs__, buffer, split_data__);
     if (err && err != LFS_ERR_RANGE) {
         return err;
     }
@@ -5236,10 +5244,10 @@ static inline int lfsr_shrub_cmp(
 //
 #define LFSR_SHRUB_DSIZE (5+4)
 
-#define LFSR_DATA_FROMSHRUB(_rbyd) \
-    lfsr_data_fromshrub(_rbyd, (uint8_t[LFSR_SHRUB_DSIZE]){0})
+#define LFSR_CAT_SHRUB(_rbyd) \
+    lfsr_cat_fromshrub(_rbyd, (uint8_t[LFSR_SHRUB_DSIZE]){0})
 
-static lfsr_data_t lfsr_data_fromshrub(const lfsr_shrub_t *shrub,
+static lfsr_cat_t lfsr_cat_fromshrub(const lfsr_shrub_t *shrub,
         uint8_t buffer[static LFSR_SHRUB_DSIZE]) {
     // shrub trunks should never be null
     LFS_ASSERT(lfsr_shrub_trunk(shrub) != 0);
@@ -5259,7 +5267,7 @@ static lfsr_data_t lfsr_data_fromshrub(const lfsr_shrub_t *shrub,
     LFS_ASSERT(d_ >= 0);
     d += d_;
 
-    return LFSR_DATA_BUF(buffer, d);
+    return LFSR_CAT_BUF(buffer, d);
 }
 
 static int lfsr_data_readshrub(lfs_t *lfs, lfsr_data_t *data,
@@ -5438,10 +5446,10 @@ static inline bool lfsr_mptr_ismrootanchor(const lfsr_mptr_t *mptr) {
 //
 #define LFSR_MPTR_DSIZE (5+5)
 
-#define LFSR_DATA_FROMMPTR(_mptr) \
-    lfsr_data_frommptr(_mptr, (uint8_t[LFSR_MPTR_DSIZE]){0})
+#define LFSR_CAT_MPTR(_mptr) \
+    lfsr_cat_frommptr(_mptr, (uint8_t[LFSR_MPTR_DSIZE]){0})
 
-static lfsr_data_t lfsr_data_frommptr(const lfsr_mptr_t *mptr,
+static lfsr_cat_t lfsr_cat_frommptr(const lfsr_mptr_t *mptr,
         uint8_t buffer[static LFSR_MPTR_DSIZE]) {
     // blocks should not exceed 31-bits
     LFS_ASSERT(mptr->blocks[0] <= 0x7fffffff);
@@ -5454,7 +5462,7 @@ static lfsr_data_t lfsr_data_frommptr(const lfsr_mptr_t *mptr,
         d += d_;
     }
 
-    return LFSR_DATA_BUF(buffer, d);
+    return LFSR_CAT_BUF(buffer, d);
 }
 
 static int lfsr_data_readmptr(lfs_t *lfs, lfsr_data_t *data,
@@ -5982,7 +5990,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                     if (tag == LFSR_TAG_DATA) {
                         err = lfsr_rbyd_appendattr(lfs, &rbyd_,
                                 rid - lfs_smax32(start_rid, 0),
-                                tag, 0, data);
+                                tag, 0, LFSR_CAT_DATA(&data));
                         if (err) {
                             return err;
                         }
@@ -6011,11 +6019,10 @@ 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, &rbyd_,
                                 rid - lfs_smax32(start_rid, 0),
-                                LFSR_TAG_BSHRUB, 0, lfsr_data_fromshrub(
-                                    &shrub, shrub_buf));
+                                LFSR_TAG_BSHRUB, 0,
+                                LFSR_CAT_SHRUB(&shrub));
                         if (err) {
                             return err;
                         }
@@ -6024,7 +6031,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                     } else {
                         err = lfsr_rbyd_appendattr(lfs, &rbyd_,
                                 rid - lfs_smax32(start_rid, 0),
-                                tag, 0, data);
+                                tag, 0, LFSR_CAT_DATA(&data));
                         if (err) {
                             return err;
                         }
@@ -6049,7 +6056,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
                                 != rbyd_.blocks[0]) {
                         int err = lfsr_rbyd_appendcompactattr(lfs, &rbyd_,
                                 LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0,
-                                file->bshrub.u.bsprout);
+                                LFSR_CAT_DATA(&file->bshrub.u.bsprout));
                         if (err) {
                             LFS_ASSERT(err != LFS_ERR_RANGE);
                             return err;
@@ -6113,14 +6120,12 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
             } else if (lfsr_tag_key(attrs[i].tag) == LFSR_TAG_SHRUBTRUNK) {
                 lfsr_shrub_t *shrub = lfsr_attr_shrubtrunk(&attrs[i]);
 
-                uint8_t shrub_buf[LFSR_SHRUB_DSIZE];
                 int err = lfsr_rbyd_appendattr(lfs, &rbyd_,
                         rid - lfs_smax32(start_rid, 0),
                         lfsr_tag_mode(attrs[i].tag) | LFSR_TAG_BSHRUB,
                         attrs[i].delta,
-                        lfsr_data_fromshrub(
-                            // note we use the staged trunk here
-                            shrub, shrub_buf));
+                        // note we use the staged trunk here
+                        LFSR_CAT_SHRUB(shrub));
                 if (err) {
                     return err;
                 }
@@ -6131,7 +6136,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
 
                 int err = lfsr_rbyd_appendattr(lfs, &rbyd_,
                         rid - lfs_smax32(start_rid, 0),
-                        attrs[i].tag, attrs[i].delta, attrs[i].data);
+                        attrs[i].tag, attrs[i].delta, attrs[i].cat);
                 if (err) {
                     return err;
                 }
@@ -6359,7 +6364,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
         // we need to update any opened inlined files
         if (tag == LFSR_TAG_DATA) {
             err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
-                    tag, weight, data);
+                    tag, weight, LFSR_CAT_DATA(&data));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
@@ -6391,10 +6396,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,
-                    tag, weight, lfsr_data_fromshrub(
-                        &shrub, shrub_buf));
+                    tag, weight, LFSR_CAT_SHRUB(&shrub));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
@@ -6403,7 +6406,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
         } else {
             // write the tag
             err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
-                    tag, weight, data);
+                    tag, weight, LFSR_CAT_DATA(&data));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
@@ -6435,7 +6438,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,
                 && file->bshrub_.u.bsprout.u.disk.block
                     != mdir_->rbyd.blocks[0]) {
             err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd,
-                    LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, file->bshrub.u.bsprout);
+                    LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0,
+                    LFSR_CAT_DATA(&file->bshrub.u.bsprout));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 return err;
@@ -6764,12 +6768,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                     0, LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_MDIR, +lfsr_mleafweight(lfs),
-                            LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mdir_))),
+                            LFSR_CAT_MPTR(lfsr_mdir_mptr(&mdir_))),
                         LFSR_ATTR(
-                            LFSR_TAG_NAME, +lfsr_mleafweight(lfs), split_data),
+                            LFSR_TAG_NAME, +lfsr_mleafweight(lfs),
+                            LFSR_CAT_DATA(&split_data)),
                         LFSR_ATTR(
                             LFSR_TAG_MDIR, 0,
-                            LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&msibling_)))));
+                            LFSR_CAT_MPTR(lfsr_mdir_mptr(&msibling_)))));
             if (err) {
                 return err;
             }
@@ -6783,12 +6788,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                     lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_MDIR, 0,
-                            LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mdir_))),
+                            LFSR_CAT_MPTR(lfsr_mdir_mptr(&mdir_))),
                         LFSR_ATTR(
-                            LFSR_TAG_NAME, +lfsr_mleafweight(lfs), split_data),
+                            LFSR_TAG_NAME, +lfsr_mleafweight(lfs),
+                            LFSR_CAT_DATA(&split_data)),
                         LFSR_ATTR(
                             LFSR_TAG_MDIR, 0,
-                            LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&msibling_)))));
+                            LFSR_CAT_MPTR(lfsr_mdir_mptr(&msibling_)))));
             if (err) {
                 return err;
             }
@@ -6822,7 +6828,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                 lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM, -lfsr_mleafweight(lfs),
-                        LFSR_DATA_NULL())));
+                        LFSR_CAT_NULL())));
         if (err) {
             return err;
         }
@@ -6852,7 +6858,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                     lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_MDIR, 0,
-                            LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mdir_)))));
+                            LFSR_CAT_MPTR(lfsr_mdir_mptr(&mdir_)))));
             if (err) {
                 return err;
             }
@@ -6912,10 +6918,10 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                 (lfsr_mtree_ismptr(&mtree_))
                     ? LFSR_ATTR(
                         LFSR_TAG_SUB | LFSR_TAG_MDIR, 0,
-                        LFSR_DATA_FROMMPTR(&mtree_.u.mptr.mptr))
+                        LFSR_CAT_MPTR(&mtree_.u.mptr.mptr))
                     : LFSR_ATTR(
                         LFSR_TAG_SUB | LFSR_TAG_MTREE, 0,
-                        LFSR_DATA_FROMBTREE(&mtree_.u.btree))));
+                        LFSR_CAT_BTREE(&mtree_.u.btree))));
         if (err) {
             LFS_ASSERT(err != LFS_ERR_RANGE);
             return err;
@@ -6950,7 +6956,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                     -1, LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_MROOT, 0,
-                            LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mrootchild_)))));
+                            LFSR_CAT_MPTR(lfsr_mdir_mptr(&mrootchild_)))));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -6982,10 +6988,10 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
                     -1, LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_MAGIC, 0,
-                            LFSR_DATA_BUF("littlefs", 8)),
+                            LFSR_CAT_BUF("littlefs", 8)),
                         LFSR_ATTR(
                             LFSR_TAG_MROOT, 0,
-                            LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mrootchild_)))));
+                            LFSR_CAT_MPTR(lfsr_mdir_mptr(&mrootchild_)))));
             if (err) {
                 LFS_ASSERT(err != LFS_ERR_RANGE);
                 LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -7007,7 +7013,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
             lfs->grm = *lfsr_attr_grm(&attrs[i]);
 
             // keep track of the exact encoding on-disk
-            lfsr_data_fromgrm(&lfs->grm, lfs->grm_g);
+            lfsr_cat_fromgrm(&lfs->grm, lfs->grm_g);
         }
 
         // adjust any opened mdirs
@@ -7972,8 +7978,8 @@ static inline bool lfsr_ocompat_isincompat(lfsr_ocompat_t ocompat) {
 //
 // little-endian, truncated bits must be assumed zero
 
-#define LFSR_DATA_FROMRCOMPAT(_rcompat) \
-    LFSR_DATA_IMM(((uint8_t[]){ \
+#define LFSR_CAT_RCOMPAT(_rcompat) \
+    LFSR_CAT_BUF(((uint8_t[]){ \
         (((_rcompat) >> 0) & 0xff), \
         (((_rcompat) >> 8) & 0xff)}), 2)
 
@@ -8008,7 +8014,7 @@ static int lfsr_data_readrcompat(lfs_t *lfs, lfsr_data_t *data,
 }
 
 // all the compat parsing is basically the same, so try to reuse code
-#define LFSR_DATA_FROMWCOMPAT(_wcompat) LFSR_DATA_NULL()
+#define LFSR_CAT_WCOMPAT(_wcompat) LFSR_CAT_RCOMPAT(_wcompat)
 
 static int lfsr_data_readwcompat(lfs_t *lfs, lfsr_data_t *data,
         lfsr_wcompat_t *wcompat) {
@@ -8032,10 +8038,10 @@ typedef struct lfsr_geometry {
 // '---+- -+- -+- -+- -'
 #define LFSR_GEOMETRY_DSIZE (4+5)
 
-#define LFSR_DATA_FROMGEOMETRY(_geometry) \
-    lfsr_data_fromgeometry(_geometry, (uint8_t[LFSR_GEOMETRY_DSIZE]){0})
+#define LFSR_CAT_GEOMETRY(_geometry) \
+    lfsr_cat_fromgeometry(_geometry, (uint8_t[LFSR_GEOMETRY_DSIZE]){0})
 
-static lfsr_data_t lfsr_data_fromgeometry(const lfsr_geometry_t *geometry,
+static lfsr_cat_t lfsr_cat_fromgeometry(const lfsr_geometry_t *geometry,
         uint8_t buffer[static LFSR_GEOMETRY_DSIZE]) {
     lfs_ssize_t d = 0;
     lfs_ssize_t d_ = lfs_toleb128(geometry->block_size-1, &buffer[d], 4);
@@ -8046,7 +8052,7 @@ static lfsr_data_t lfsr_data_fromgeometry(const lfsr_geometry_t *geometry,
     LFS_ASSERT(d_ >= 0);
     d += d_;
 
-    return LFSR_DATA_BUF(buffer, d);
+    return LFSR_CAT_BUF(buffer, d);
 }
 
 static int lfsr_data_readgeometry(lfs_t *lfs, lfsr_data_t *data,
@@ -8430,29 +8436,29 @@ static int lfsr_formatinited(lfs_t *lfs) {
         err = lfsr_rbyd_commit(lfs, &rbyd, -1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_MAGIC, 0,
-                    LFSR_DATA_BUF("littlefs", 8)),
+                    LFSR_CAT_BUF("littlefs", 8)),
                 LFSR_ATTR(
                     LFSR_TAG_VERSION, 0,
-                    LFSR_DATA_IMM(((const uint8_t[2]){
+                    LFSR_CAT_BUF(((const uint8_t[2]){
                         LFS_DISK_VERSION_MAJOR,
                         LFS_DISK_VERSION_MINOR}), 2)),
                 LFSR_ATTR(
                     LFSR_TAG_RCOMPAT, 0,
-                    LFSR_DATA_FROMRCOMPAT(LFSR_RCOMPAT_COMPAT)),
+                    LFSR_CAT_RCOMPAT(LFSR_RCOMPAT_COMPAT)),
                 LFSR_ATTR(
                     LFSR_TAG_GEOMETRY, 0,
-                    LFSR_DATA_FROMGEOMETRY((&(lfsr_geometry_t){
+                    LFSR_CAT_GEOMETRY((&(lfsr_geometry_t){
                         lfs->cfg->block_size,
                         lfs->cfg->block_count}))),
                 LFSR_ATTR(
                     LFSR_TAG_NAMELIMIT, 0,
-                    LFSR_DATA_LEB128(lfs->name_limit)),
+                    LFSR_CAT_LLEB128(lfs->name_limit)),
                 LFSR_ATTR(
                     LFSR_TAG_SIZELIMIT, 0,
-                    LFSR_DATA_LEB128(lfs->size_limit)),
+                    LFSR_CAT_LEB128(lfs->size_limit)),
                 LFSR_ATTR(
                     LFSR_TAG_BOOKMARK, +1,
-                    LFSR_DATA_LEB128(0))));
+                    LFSR_CAT_LEB128(0))));
         if (err) {
             return err;
         }
@@ -8709,8 +8715,8 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) {
         LFS_ASSERT(lfsr_mid_rid(lfs, lfs->grm.rms[0])
                 < (lfsr_srid_t)mdir.rbyd.weight);
         err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
-                LFSR_ATTR(LFSR_TAG_GRM, 0, LFSR_DATA_GRM(&grm))));
+                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()),
+                LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &grm)));
     }
 
     return 0;
@@ -8741,7 +8747,7 @@ static int lfsr_fs_fixorphans(lfs_t *lfs) {
             if (err != LFS_ERR_NOENT) {
                 // remove orphaned file
                 err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
-                        LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
+                        LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL())));
                 if (err) {
                     return err;
                 }
@@ -8944,10 +8950,8 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) {
 
     // commit our bookmark and a grm to self-remove in case of powerloss
     err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_BOOKMARK, +1, LFSR_DATA_LEB128(did_)),
-            LFSR_ATTR(
-                LFSR_TAG_GRM, 0,
-                LFSR_DATA_GRM(&((lfsr_grm_t){{mdir.mid, -1}})))));
+            LFSR_ATTR(LFSR_TAG_BOOKMARK, +1, LFSR_CAT_LEB128(did_)),
+            LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &((lfsr_grm_t){{mdir.mid, -1}}))));
     if (err) {
         return err;
     }
@@ -8967,13 +8971,9 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) {
     err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUP | LFSR_TAG_DIR, (!exists) ? +1 : 0,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(did),
-                    LFSR_DATA_BUF(name, name_size))),
-            LFSR_ATTR(LFSR_TAG_DID, 0, LFSR_DATA_LEB128(did_)),
-            LFSR_ATTR(
-                LFSR_TAG_GRM, 0,
-                LFSR_DATA_GRM(&((lfsr_grm_t){{-1, -1}})))));
+                LFSR_CAT_NAME(did, name, name_size)),
+            LFSR_ATTR(LFSR_TAG_DID, 0, LFSR_CAT_LEB128(did_)),
+            LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &((lfsr_grm_t){{-1, -1}}))));
     if (err) {
         return err;
     }
@@ -9074,12 +9074,10 @@ int lfsr_remove(lfs_t *lfs, const char *path) {
             (zombie)
                 ? LFSR_ATTR(
                     LFSR_TAG_SUP | LFSR_TAG_ORPHAN, 0,
-                    LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(did),
-                        LFSR_DATA_BUF(name, name_size)))
+                    LFSR_CAT_NAME(did, name, name_size))
                 : LFSR_ATTR(
-                    LFSR_TAG_RM, -1, LFSR_DATA_NULL()),
-            LFSR_ATTR(LFSR_TAG_GRM, 0, LFSR_DATA_GRM(&grm))));
+                    LFSR_TAG_RM, -1, LFSR_CAT_NULL()),
+            LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &grm)));
     if (err) {
         return err;
     }
@@ -9224,11 +9222,9 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) {
     err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUP | old_tag, (!exists) ? +1 : 0,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(new_did),
-                    LFSR_DATA_BUF(new_name, new_name_size))),
-            LFSR_ATTR(LFSR_TAG_MOVE, 0, LFSR_DATA_MOVE(&old_mdir)),
-            LFSR_ATTR(LFSR_TAG_GRM, 0, LFSR_DATA_GRM(&grm))));
+                LFSR_CAT_NAME(new_did, new_name, new_name_size)),
+            LFSR_ATTR_MOVE(LFSR_TAG_MOVE, 0, &old_mdir),
+            LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &grm)));
     if (err) {
         return err;
     }
@@ -9705,9 +9701,7 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file,
             err = lfsr_mdir_commit(lfs, &file->m.mdir, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_ORPHAN, +1,
-                        LFSR_DATA_CAT(
-                            LFSR_DATA_LEB128(did),
-                            LFSR_DATA_BUF(name, name_size)))));
+                        LFSR_CAT_NAME(did, name, name_size))));
             if (err) {
                 return err;
             }
@@ -10162,11 +10156,12 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_file_t *file,
     // we need some scratch space for tail-recursive attrs
     lfsr_attr_t attrs__[4];
     uint8_t buffer[2*LFSR_BRANCH_DSIZE];
+    lfsr_data_t split_data__[1];
 
     // try to commit to the btree
     int err = lfsr_btree_commit_(lfs, &file->bshrub.u.btree,
             &bid, &attrs, &attr_count,
-            attrs__, buffer);
+            attrs__, buffer, split_data__);
     if (err && err != LFS_ERR_RANGE) {
         return err;
     }
@@ -10194,7 +10189,7 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_file_t *file,
                     && !lfsr_tag_isrm(attrs[i].tag)) {
                 commit_estimate += lfs->attr_estimate;
             }
-            commit_estimate += lfsr_data_size(attrs[i].data);
+            commit_estimate += lfsr_cat_size(attrs[i].cat);
         }
 
         // does our estimate exceed our shrub_size? need to recalculate an
@@ -10229,12 +10224,12 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_file_t *file,
 
         // commit to shrub
         int err = lfsr_mdir_commit(lfs, &file->m.mdir, LFSR_ATTRS(
-                LFSR_ATTR(
+                LFSR_ATTR_SHRUBCOMMIT(
                     (alloc)
                         ? LFSR_TAG_SHRUBALLOC
                         : LFSR_TAG_SHRUBCOMMIT, 0,
-                    LFSR_DATA_SHRUBCOMMIT(&file->bshrub_.u.bshrub, bid,
-                        attrs, attr_count))));
+                    &file->bshrub_.u.bshrub, bid,
+                    attrs, attr_count)));
         if (err) {
             return err;
         }
@@ -10291,7 +10286,7 @@ evict:;
 
 static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         lfs_off_t pos, lfs_off_t weight, lfs_soff_t delta,
-        lfsr_tag_t tag, const lfsr_bptr_t *bptr) {
+        lfsr_tag_t tag, lfsr_cat_t cat) {
     // Note! This function has some rather special constraints:
     //
     // 1. We must never allow our btree size to overflow, even temporarily.
@@ -10311,7 +10306,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
     lfsr_bid_t bid = lfsr_bshrub_size(&file->bshrub);
     lfsr_attr_t attrs[5];
     lfs_size_t attr_count = 0;
-    uint8_t buf[3*LFSR_BPTR_DSIZE];
+    uint8_t buf[2*LFSR_BPTR_DSIZE];
     lfs_size_t buf_size = 0;
 
     // always convert to bshrub/btree when this function is called
@@ -10322,11 +10317,11 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         if (lfsr_bshrub_isbsprout(&file->m.mdir, &file->bshrub)) {
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_DATA, +lfsr_bshrub_size(&file->bshrub),
-                    file->bshrub.u.bsprout);
+                    LFSR_CAT_DATA(&file->bshrub.u.bsprout));
         } else if (lfsr_bshrub_isbptr(&file->m.mdir, &file->bshrub)) {
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_BLOCK, +lfsr_bshrub_size(&file->bshrub),
-                    lfsr_data_frombptr(&file->bshrub.u.bptr, &buf[buf_size]));
+                    lfsr_cat_frombptr(&file->bshrub.u.bptr, &buf[buf_size]));
             buf_size += LFSR_BPTR_DSIZE;
         }
 
@@ -10357,14 +10352,14 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
             bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)-1);
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_GROW, +(pos - lfsr_bshrub_size(&file->bshrub)),
-                    LFSR_DATA_NULL());
+                    LFSR_CAT_NULL());
 
         // new hole
         } else {
             bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub));
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_DATA, +(pos - lfsr_bshrub_size(&file->bshrub)),
-                    LFSR_DATA_NULL());
+                    LFSR_CAT_NULL());
         }
     }
 
@@ -10372,6 +10367,9 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
     lfsr_tag_t right_tag_ = 0;
     lfsr_bid_t right_weight_;
     lfsr_bptr_t right_bptr_;
+    // TODO should we handle left/right slice/bptr differently? allocate
+    // from buf maybe?
+    lfsr_data_t left_slice_;
     while (pos < lfsr_bshrub_size(&file->bshrub)) {
         lfsr_tag_t tag_;
         lfsr_bid_t weight_;
@@ -10384,7 +10382,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         }
 
         // note, an entry can be both a left and right sibling
-        lfsr_data_t left_slice_ = lfsr_data_slice(bptr_.data,
+        left_slice_ = lfsr_data_slice(bptr_.data,
                 -1,
                 pos - (bid-(weight_-1)));
         lfsr_data_t right_slice_ = lfsr_data_slice(bptr_.data,
@@ -10404,11 +10402,12 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
                     LFSR_ATTR(
                         LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA,
                             -(weight_ - lfs->cfg->fragment_size),
-                        lfsr_data_truncate(left_slice_,
-                            lfs->cfg->fragment_size)),
+                        LFSR_CAT_CAT(
+                            lfsr_data_truncate(left_slice_,
+                                lfs->cfg->fragment_size))),
                     LFSR_ATTR(
                         LFSR_TAG_BLOCK, +(weight_ - lfs->cfg->fragment_size),
-                        LFSR_DATA_FROMBPTR(&bptr_))));
+                        LFSR_CAT_BPTR(&bptr_))));
             if (err) {
                 return err;
             }
@@ -10432,12 +10431,13 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
                     LFSR_ATTR(
                         LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK,
                             -(weight_ - lfsr_data_size(bptr_.data)),
-                        LFSR_DATA_FROMBPTR(&bptr_)),
+                        LFSR_CAT_BPTR(&bptr_)),
                     LFSR_ATTR(
                         LFSR_TAG_DATA,
                             +(weight_ - lfsr_data_size(bptr_.data)),
-                        lfsr_data_fruncate(right_slice_,
-                            lfs->cfg->fragment_size))));
+                        LFSR_CAT_CAT(
+                            lfsr_data_fruncate(right_slice_,
+                                lfs->cfg->fragment_size)))));
             if (err) {
                 return err;
             }
@@ -10454,21 +10454,21 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
             // can we get away with a grow attribute?
             if (lfsr_data_size(bptr_.data) == lfsr_data_size(left_slice_)) {
                 attrs[attr_count++] = LFSR_ATTR(
-                        LFSR_TAG_GROW, -(bid+1 - pos), LFSR_DATA_NULL());
+                        LFSR_TAG_GROW, -(bid+1 - pos), LFSR_CAT_NULL());
 
             // carve fragment?
             } else if (tag_ == LFSR_TAG_DATA) {
                 attrs[attr_count++] = LFSR_ATTR(
                         LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA,
                             -(bid+1 - pos),
-                        left_slice_);
+                        LFSR_CAT_DATA(&left_slice_));
 
             // carve bptr?
             } else if (tag_ == LFSR_TAG_BLOCK) {
                 attrs[attr_count++] = LFSR_ATTR(
                         LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK,
                             -(bid+1 - pos),
-                        lfsr_data_frombptr(
+                        lfsr_cat_frombptr(
                             &(lfsr_bptr_t){
                                 .data = left_slice_,
                                 .cksize = bptr_.cksize,
@@ -10483,7 +10483,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         // completely overwriting this entry?
         } else {
             attrs[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_RM, -weight_, LFSR_DATA_NULL());
+                    LFSR_TAG_RM, -weight_, LFSR_CAT_NULL());
         }
 
         // spans more than one entry? we can't do everything in one commit,
@@ -10541,33 +10541,22 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
     // append our data
     if (weight + delta > 0) {
         // can we coalesce a hole?
-        if ((!bptr || lfsr_data_size(bptr->data) == 0) && pos > 0) {
+        if (lfsr_cat_size(cat) == 0 && pos > 0) {
             bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)-1);
             attrs[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_GROW, +(weight + delta), LFSR_DATA_NULL());
+                    LFSR_TAG_GROW, +(weight + delta), LFSR_CAT_NULL());
 
         // need a new hole?
-        } else if (!bptr || lfsr_data_size(bptr->data) == 0) {
+        } else if (lfsr_cat_size(cat) == 0) {
             bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub));
             attrs[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_DATA, +(weight + delta), LFSR_DATA_NULL());
-
-        // append new fragment?
-        } else if (tag == LFSR_TAG_DATA) {
-            bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub));
-            attrs[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_DATA, +(weight + delta), bptr->data);
-
-        // append a new block?
-        } else if (tag == LFSR_TAG_BLOCK) {
-            bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub));
-            attrs[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_BLOCK, +(weight + delta),
-                    lfsr_data_frombptr(bptr, &buf[buf_size]));
-            buf_size += LFSR_BPTR_DSIZE;
+                    LFSR_TAG_DATA, +(weight + delta), LFSR_CAT_NULL());
 
+        // append new fragment/bptr?
         } else {
-            LFS_UNREACHABLE();
+            bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub));
+            attrs[attr_count++] = LFSR_ATTR(
+                    tag, +(weight + delta), cat);
         }
     }
 
@@ -10577,13 +10566,13 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
         if (right_tag_ == LFSR_TAG_DATA) {
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_DATA, +right_weight_,
-                    right_bptr_.data);
+                    LFSR_CAT_DATA(&right_bptr_.data));
 
         // right bptr?
         } else if (right_tag_ == LFSR_TAG_BLOCK) {
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_BLOCK, +right_weight_,
-                    lfsr_data_frombptr(&right_bptr_, &buf[buf_size]));
+                    lfsr_cat_frombptr(&right_bptr_, &buf[buf_size]));
             buf_size += LFSR_BPTR_DSIZE;
 
         } else {
@@ -10930,7 +10919,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
         // and write it into our tree
         err = lfsr_file_carve(lfs, file,
                 block_start, block_end - block_start, 0,
-                LFSR_TAG_BLOCK, &bptr);
+                LFSR_TAG_BLOCK, LFSR_CAT_BPTR(&bptr));
         if (err) {
             return err;
         }
@@ -11037,10 +11026,9 @@ fragment:;
 
         // once we've figured out what fragment to write, carve it into
         // our tree
-        lfsr_data_t data = lfsr_data_fromcat(datas, data_count);
         int err = lfsr_file_carve(lfs, file,
                 fragment_start, fragment_end - fragment_start, 0,
-                LFSR_TAG_DATA, (const lfsr_bptr_t*)&data);
+                LFSR_TAG_DATA, LFSR_CAT_DATAS(datas, data_count));
         if (err && err != LFS_ERR_RANGE) {
             return err;
         }
@@ -11415,10 +11403,11 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
         lfs_size_t attr_count = 0;
         uint8_t buf[LFSR_BTREE_DSIZE];
         lfs_size_t buf_size = 0;
+        // TODO should we carve this out of buf?
+        lfsr_data_t data;
 
         // not created yet? need to convert orphan to normal file
         if (lfsr_f_isorphan(file->m.flags)) {
-            lfsr_data_t data;
             err = lfsr_mdir_lookup(lfs, &file->m.mdir, LFSR_TAG_ORPHAN,
                     &data);
             if (err) {
@@ -11428,7 +11417,8 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
             }
 
             attrs[attr_count++] = LFSR_ATTR(
-                    LFSR_TAG_SUB | LFSR_TAG_REG, 0, data);
+                    LFSR_TAG_SUB | LFSR_TAG_REG, 0,
+                    LFSR_CAT_DATA(&data));
         }
 
         // commit the file state
@@ -11437,22 +11427,22 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
         if (lfsr_f_isunflush(file->m.flags) && file->buffer_size == 0) {
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_STRUCT, 0,
-                    LFSR_DATA_NULL());
+                    LFSR_CAT_NULL());
         // small file inlined in mdir?
         } else if (lfsr_f_isunflush(file->m.flags)) {
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(file->buffer, file->buffer_size));
+                    LFSR_CAT_BUF(file->buffer, file->buffer_size));
         // bshrub?
         } else if (lfsr_bshrub_isbshrub(&file->m.mdir, &file->bshrub)) {
-            attrs[attr_count++] = LFSR_ATTR(
+            attrs[attr_count++] = LFSR_ATTR_SHRUBTRUNK(
                     LFSR_TAG_SUB | LFSR_TAG_SHRUBTRUNK, 0,
-                    LFSR_DATA_SHRUBTRUNK(&file->bshrub_.u.bshrub));
+                    &file->bshrub_.u.bshrub);
         // btree?
         } else if (lfsr_bshrub_isbtree(&file->m.mdir, &file->bshrub)) {
             attrs[attr_count++] = LFSR_ATTR(
                     LFSR_TAG_SUB | LFSR_TAG_BTREE, 0,
-                    lfsr_data_frombtree(
+                    lfsr_cat_frombtree(
                         &file->bshrub.u.btree,
                         &buf[buf_size]));
             buf_size += LFSR_BTREE_DSIZE;
@@ -11621,7 +11611,7 @@ int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) {
                 lfs_min32(size, size_),
                 size - lfs_min32(size, size_),
                 +size_ - size,
-                LFSR_TAG_DATA, NULL);
+                LFSR_TAG_DATA, LFSR_CAT_NULL());
         if (err) {
             goto failed;
         }
@@ -11739,7 +11729,7 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) {
                 0,
                 lfs_smax32(size - size_, 0),
                 +size_ - size,
-                LFSR_TAG_DATA, NULL);
+                LFSR_TAG_DATA, LFSR_CAT_NULL());
         if (err) {
             goto failed;
         }
diff --git a/lfs.h b/lfs.h
index 7132bbe9..19d43aa3 100644
--- a/lfs.h
+++ b/lfs.h
@@ -393,18 +393,10 @@ typedef struct lfs_mdir {
     lfs_block_t tail[2];
 } lfs_mdir_t;
 
-// Either an on-disk or in-device data pointer
-//
-// The top 2 bits of data's size indicates the actual encoding
-// 0b00 => in-RAM buffer
-// 0b01 => a single leb128
-// 0b10 => on-disk reference
-// 0b11 => concatenated datas
-//
-// Note concatenated datas can only be 1 level deep. Concatenating
-// concatenated datas would require recursion to resolve.
-//
+// either an on-disk or in-device data pointer
 typedef struct lfsr_data {
+    // sign(size)=0 => in-RAM buffer
+    // sign(size)=1 => on-disk reference
     union {
         lfs_size_t size;
         struct {
@@ -416,14 +408,6 @@ typedef struct lfsr_data {
             lfs_size_t size;
             const uint8_t *buffer;
         } buf;
-        struct {
-            lfs_size_t size;
-            uint8_t buf[8];
-        } imm;
-        struct {
-            lfs_size_t size;
-            const struct lfsr_data *datas;
-        } cat;
     } u;
 } lfsr_data_t;
 
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index 5a28fe6b..19248506 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -55,7 +55,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -97,9 +97,9 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("b", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -147,9 +147,9 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -198,11 +198,11 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("c", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -257,11 +257,11 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -323,7 +323,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -379,7 +379,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -449,7 +449,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -524,7 +524,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +W,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -620,7 +620,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +weight,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -734,12 +734,12 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0;
     // update the tree
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF("A", 1)))) => 0;
+                LFSR_CAT_BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -780,18 +780,18 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("b", 1)))) => 0;
     // update the tree
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF("A", 1)))) => 0;
+                LFSR_CAT_BUF("A", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF("B", 1)))) => 0;
+                LFSR_CAT_BUF("B", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -839,24 +839,24 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("c", 1)))) => 0;
     // update the tree
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF("A", 1)))) => 0;
+                LFSR_CAT_BUF("A", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF("B", 1)))) => 0;
+                LFSR_CAT_BUF("B", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF("C", 1)))) => 0;
+                LFSR_CAT_BUF("C", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -915,7 +915,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -931,7 +931,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -991,7 +991,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1021,7 +1021,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -1092,7 +1092,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +W,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1108,7 +1108,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1183,7 +1183,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +W,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1224,10 +1224,10 @@ code = '''
                 weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                        LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)),
+                        LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1)),
                     LFSR_ATTR(
                         LFSR_TAG_GROW, +weight-sim_weights[bid],
-                        LFSR_DATA_NULL())));
+                        LFSR_CAT_NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -1338,10 +1338,10 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0;
     // pop!
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1359,7 +1359,7 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1395,12 +1395,12 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("b", 1)))) => 0;
     // pop!
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1425,7 +1425,7 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("B", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1468,12 +1468,12 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("b", 1)))) => 0;
     // pop!
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1498,7 +1498,7 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("A", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1541,14 +1541,14 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("c", 1)))) => 0;
     // pop!
     lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1580,7 +1580,7 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("C", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -1636,7 +1636,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1650,7 +1650,7 @@ code = '''
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
         int err = lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
+                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1689,7 +1689,7 @@ code = '''
 
     // try recovering
     lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("R", 1)))) => 0;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_lookup(&lfs, &btree, i,
@@ -1734,7 +1734,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1748,7 +1748,7 @@ code = '''
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
         int err = lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
+                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1787,7 +1787,7 @@ code = '''
 
     // try recovering
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("R", 1)))) => 0;
 
     lfsr_btree_lookup(&lfs, &btree, 0,
             &tag_, &weight_, &data_) => 0;
@@ -1834,7 +1834,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1863,7 +1863,7 @@ code = '''
 
         // remove from btree
         int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
+                LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -1937,7 +1937,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +W,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1951,7 +1951,7 @@ code = '''
     // drain the tree
     for (lfs_size_t i = 0; i < N-REMAINING; i++) {
         int err = lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL())));
+                LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_CAT_NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -1989,7 +1989,7 @@ code = '''
 
     // try recovering
     lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("R", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_CAT_BUF("R", 1)))) => 0;
 
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         lfsr_btree_lookup(&lfs, &btree, i*W+W-1,
@@ -2081,7 +2081,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +weight,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             printf("btree: w%d 0x%x.%x\n",
@@ -2112,7 +2112,7 @@ code = '''
                 weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM, -sim_weights[bid],
-                        LFSR_DATA_NULL())));
+                        LFSR_CAT_NULL())));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2225,16 +2225,16 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_DATA, +1,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0;
+                LFSR_CAT_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0;
     lfs_size_t n = 1;
     for (lfs_size_t i = 1; i < N; i++) {
         int err = lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)),
+                    LFSR_CAT_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2287,7 +2287,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -2307,10 +2307,10 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2384,16 +2384,16 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_DATA, +W,
-                LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0;
+                LFSR_CAT_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0;
     lfs_size_t n = 1;
     for (lfs_size_t i = 1; i < N; i++) {
         int err = lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)),
+                    LFSR_CAT_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +W,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2447,7 +2447,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("_", 1)))) => 0;
+            LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_CAT_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -2480,13 +2480,13 @@ code = '''
                 weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_GROW, +weight1-sim_weights[bid],
-                        LFSR_DATA_NULL()),
+                        LFSR_CAT_NULL()),
                     LFSR_ATTR(
                         LFSR_TAG_DATA, 0,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
                     LFSR_ATTR(
                         LFSR_TAG_DATA, +weight2,
-                        LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
+                        LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -2633,27 +2633,27 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF(buf1, SIZE)),
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF(buf2, SIZE)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2701,21 +2701,21 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF(buf1, SIZE)),
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF(buf2, SIZE)))) => 0;
+                LFSR_CAT_BUF(buf2, SIZE)))) => 0;
     assert(btree.weight == 2);
 
     // now remove one entry, since this brings the rbyd down this zero,
@@ -2724,7 +2724,7 @@ 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2772,14 +2772,14 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF(buf1, SIZE)),
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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
@@ -2788,7 +2788,7 @@ code = '''
     //
     btree.eoff = -1;
     lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2836,38 +2836,38 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_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_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF(buf1, SIZE)),
+            LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF(buf2, SIZE)))) => 0;
     // force compaction
     btree.eoff = -1;
     memset(buf2, 'b', SIZE);
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF(buf2, SIZE)))) => 0;
+                LFSR_CAT_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_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF("a", 1)))) => 0;
+                LFSR_CAT_BUF("a", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF("b", 1)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -2932,7 +2932,7 @@ code = '''
             int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_DATA, +1,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -2949,7 +2949,7 @@ code = '''
             int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -2962,7 +2962,7 @@ code = '''
         } else {
             // pop from btree
             int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
+                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -3063,7 +3063,7 @@ code = '''
             int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_DATA, +weight,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -3084,10 +3084,10 @@ code = '''
                     weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                            LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
+                            LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)),
                         LFSR_ATTR(
                             LFSR_TAG_GROW, +weight-sim_weights[bid],
-                            LFSR_DATA_NULL())));
+                            LFSR_CAT_NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -3104,7 +3104,7 @@ code = '''
                     weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_RM, -sim_weights[bid],
-                            LFSR_DATA_NULL())));
+                            LFSR_CAT_NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -3251,8 +3251,8 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
+                LFSR_CAT_NAME(0, "aaa", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("0", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3304,14 +3304,14 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
+                LFSR_CAT_NAME(0, "aaa", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_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(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("0", 1)),
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aab", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
+                LFSR_CAT_NAME(0, "aab", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3371,26 +3371,20 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(0),
-                    LFSR_DATA_BUF("aaa", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
+                LFSR_CAT_NAME(0, "aaa", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_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(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("0", 1)),
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(1*DID),
-                    LFSR_DATA_BUF("aab", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
+                LFSR_CAT_NAME(1*DID, "aab", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_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(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("1", 1)),
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(2*DID),
-                    LFSR_DATA_BUF("aac", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
+                LFSR_CAT_NAME(2*DID, "aac", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("2", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3458,26 +3452,20 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(0),
-                    LFSR_DATA_BUF("aaa", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
+                LFSR_CAT_NAME(0, "aaa", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_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(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("1", 1)),
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(2*DID),
-                    LFSR_DATA_BUF("aac", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
+                LFSR_CAT_NAME(2*DID, "aac", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_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(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("0", 1)),
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(1*DID),
-                    LFSR_DATA_BUF("aab", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
+                LFSR_CAT_NAME(1*DID, "aab", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
             btree.blocks[0],
@@ -3549,10 +3537,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))),
+                LFSR_CAT_NAME(0, name, 3)),
             LFSR_ATTR(
                 LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
+                LFSR_CAT_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
     lfs_size_t n = 1;
     for (lfs_size_t i = 1; i < N; i++) {
         char name[3] = {
@@ -3561,14 +3549,13 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
+                    LFSR_CAT_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
                 LFSR_ATTR(
-                    LFSR_TAG_NAME, +1, LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(i*DID),
-                        LFSR_DATA_BUF(name, 3))),
+                    LFSR_TAG_NAME, +1,
+                    LFSR_CAT_NAME(i*DID, name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -3625,8 +3612,8 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
+                LFSR_CAT_NAME(0, "___", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -3662,15 +3649,13 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
+                    LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
                 LFSR_ATTR(
                     LFSR_TAG_NAME, +1,
-                    LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(0),
-                        LFSR_DATA_BUF(name, 3))),
+                    LFSR_CAT_NAME(0, name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -3750,10 +3735,10 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))),
+                LFSR_CAT_NAME(0, name, 3)),
             LFSR_ATTR(
                 LFSR_TAG_DATA, 0,
-                LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
+                LFSR_CAT_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
     lfs_size_t n = 1;
     for (lfs_size_t i = 1; i < N; i++) {
         char name[3] = {
@@ -3762,15 +3747,13 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
+                    LFSR_CAT_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
                 LFSR_ATTR(
                     LFSR_TAG_NAME, +W,
-                    LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(i*DID),
-                        LFSR_DATA_BUF(name, 3))),
+                    LFSR_CAT_NAME(i*DID, name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
-                    LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -3828,8 +3811,8 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
+                LFSR_CAT_NAME(0, "___", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -3878,18 +3861,16 @@ code = '''
                 weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_GROW, +weight1-sim_weights[bid],
-                        LFSR_DATA_NULL()),
+                        LFSR_CAT_NULL()),
                     LFSR_ATTR(
                         LFSR_TAG_DATA, 0,
-                        LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
+                        LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
                     LFSR_ATTR(
                         LFSR_TAG_NAME, +weight2,
-                        LFSR_DATA_CAT(
-                            LFSR_DATA_LEB128(0),
-                            LFSR_DATA_BUF(name, 3))),
+                        LFSR_CAT_NAME(0, name, 3)),
                     LFSR_ATTR(
                         LFSR_TAG_DATA, 0,
-                        LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
+                        LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -3991,8 +3972,8 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
+                LFSR_CAT_NAME(0, "___", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -4042,12 +4023,10 @@ code = '''
                         split_bid, LFSR_ATTRS(
                             LFSR_ATTR(
                                 LFSR_TAG_NAME, +1,
-                                LFSR_DATA_CAT(
-                                    LFSR_DATA_LEB128(0),
-                                    LFSR_DATA_BUF(name, 3))),
+                                LFSR_CAT_NAME(0, name, 3)),
                             LFSR_ATTR(
                                 LFSR_TAG_DATA, 0,
-                                LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
+                                LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
                 // ignore space issues
                 if (err == LFS_ERR_NOSPC) {
                     break;
@@ -4055,15 +4034,15 @@ code = '''
                 assert(err == 0);
             } else {
                 int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
-                        LFSR_ATTR(LFSR_TAG_DATA, 0, split_data),
-                        LFSR_ATTR(
-                            LFSR_TAG_NAME, +1,
-                            LFSR_DATA_CAT(
-                                LFSR_DATA_LEB128(0),
-                                LFSR_DATA_BUF(name, 3))),
                         LFSR_ATTR(
                             LFSR_TAG_DATA, 0,
-                            LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
+                            LFSR_CAT_DATA(&split_data)),
+                        LFSR_ATTR(
+                            LFSR_TAG_NAME, +1,
+                            LFSR_CAT_NAME(0, name, 3)),
+                        LFSR_ATTR(
+                            LFSR_TAG_DATA, 0,
+                            LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
                 // ignore space issues
                 if (err == LFS_ERR_NOSPC) {
                     break;
@@ -4083,7 +4062,7 @@ code = '''
             int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                        LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
+                        LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -4096,7 +4075,7 @@ code = '''
         } else {
             // pop from btree
             int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())));
+                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -4169,8 +4148,8 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
-            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
+                LFSR_CAT_NAME(0, "___", 3)),
+            LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
     //
@@ -4232,12 +4211,10 @@ code = '''
                         split_bid-(split_weight-1), LFSR_ATTRS(
                             LFSR_ATTR(
                                 LFSR_TAG_NAME, +weight,
-                                LFSR_DATA_CAT(
-                                    LFSR_DATA_LEB128(0),
-                                    LFSR_DATA_BUF(name, 3))),
+                                LFSR_CAT_NAME(0, name, 3)),
                             LFSR_ATTR(
                                 LFSR_TAG_DATA, 0,
-                                LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
+                                LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
                 // ignore space issues
                 if (err == LFS_ERR_NOSPC) {
                     break;
@@ -4245,15 +4222,15 @@ code = '''
                 assert(err == 0);
             } else {
                 int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
-                        LFSR_ATTR(LFSR_TAG_DATA, 0, split_data),
-                        LFSR_ATTR(
-                            LFSR_TAG_NAME, +weight,
-                            LFSR_DATA_CAT(
-                                LFSR_DATA_LEB128(0),
-                                LFSR_DATA_BUF(name, 3))),
                         LFSR_ATTR(
                             LFSR_TAG_DATA, 0,
-                            LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
+                            LFSR_CAT_DATA(&split_data)),
+                        LFSR_ATTR(
+                            LFSR_TAG_NAME, +weight,
+                            LFSR_CAT_NAME(0, name, 3)),
+                        LFSR_ATTR(
+                            LFSR_TAG_DATA, 0,
+                            LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
                 // ignore space issues
                 if (err == LFS_ERR_NOSPC) {
                     break;
@@ -4277,10 +4254,10 @@ code = '''
                     weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_SUB | LFSR_TAG_DATA, 0,
-                            LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
+                            LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
                         LFSR_ATTR(
                             LFSR_TAG_GROW, +weight-sim_weights[bid],
-                            LFSR_DATA_NULL())));
+                            LFSR_CAT_NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -4297,7 +4274,7 @@ code = '''
                     weighted_bid+sim_weights[bid]-1, LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_RM, -sim_weights[bid],
-                            LFSR_DATA_NULL())));
+                            LFSR_CAT_NULL())));
             // ignore space issues
             if (err == LFS_ERR_NOSPC) {
                 break;
@@ -4398,7 +4375,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
@@ -4538,7 +4515,7 @@ code = '''
         int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_DATA, +1,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1))));
         // ignore space issues
         if (err == LFS_ERR_NOSPC) {
             break;
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index 541c0f36..dbb49f34 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -28,7 +28,7 @@ code = '''
         lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(i), 0,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
 
     for (lfs_size_t i = 0; i < N; i++) {
@@ -73,7 +73,7 @@ code = '''
         lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(i), 0,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
     }
 
     for (lfs_size_t i = 0; i < N; i++) {
@@ -115,7 +115,7 @@ code = '''
         lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(1), 0,
-                    LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+                    LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         lfsr_data_t data;
 
         uint8_t buffer[4];
@@ -162,13 +162,13 @@ code = '''
     uint8_t buffer[SIZE];
     memset(buffer, 'a', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
 
     memset(buffer, 'b', SIZE);
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0;
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
@@ -232,14 +232,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -308,14 +308,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -332,7 +332,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mdir to compact
@@ -420,7 +420,7 @@ code = '''
             mdir.rbyd.eoff = -1;
         }
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0;
         lfsr_data_t data;
 
         uint8_t buffer[256];
@@ -510,7 +510,7 @@ code = '''
             mdir.rbyd.eoff = -1;
         }
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0;
         lfsr_data_t data;
 
         // double check
@@ -593,14 +593,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -617,7 +617,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped
@@ -670,14 +670,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -696,7 +696,7 @@ code = '''
     // 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped
@@ -749,14 +749,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // remove an entry, forcing the mdir to be dropped
@@ -767,7 +767,7 @@ 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // assert split/drop worked out
@@ -820,14 +820,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -844,7 +844,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // remove an entry, forcing the mdir to be dropped
@@ -854,7 +854,7 @@ code = '''
     // 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 1);
 
     // assert split/drop worked out
@@ -919,14 +919,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -943,7 +943,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // remove an entry, forcing the mdir to be dropped
@@ -953,7 +953,7 @@ code = '''
     // 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 1);
 
     // assert split/drop worked out
@@ -1045,7 +1045,7 @@ code = '''
                 mdir.rbyd.eoff = -1;
             }
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+                    LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0;
             lfsr_data_t data;
 
             // double check
@@ -1074,7 +1074,7 @@ code = '''
                 mdir.rbyd.eoff = -1;
             }
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
         }
     }
 
@@ -1149,13 +1149,13 @@ code = '''
     uint8_t buffer[SIZE];
     memset(buffer, 'a', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
 
     memset(buffer, 'b', SIZE);
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0;
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
@@ -1171,10 +1171,10 @@ code = '''
     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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -1238,14 +1238,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -1264,10 +1264,10 @@ code = '''
     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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -1335,14 +1335,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -1361,10 +1361,10 @@ code = '''
     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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -1432,7 +1432,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
@@ -1489,7 +1489,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
@@ -1557,7 +1557,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
@@ -1620,14 +1620,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -1649,10 +1649,10 @@ code = '''
     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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
     // assert mroot relocated
@@ -1722,14 +1722,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -1746,7 +1746,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // setup mroot to compact and relocate on next commit
@@ -1756,10 +1756,10 @@ code = '''
     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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
     // assert mroot relocated
@@ -1841,14 +1841,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -1870,11 +1870,11 @@ code = '''
     // force mdir to compact twice, this should relocate
     mdir.rbyd.eoff = -1;
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 0);
     // assert mroot relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -1932,13 +1932,13 @@ code = '''
     uint8_t buffer[SIZE];
     memset(buffer, 'a', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
 
     memset(buffer, 'b', SIZE);
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0;
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact, this should both uninline and relocate
     lfsr_mdir_t old_mroot = lfs.mroot;
@@ -2012,14 +2012,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact, this should both split and relocate
@@ -2120,7 +2120,7 @@ code = '''
                 mdir.rbyd.eoff = -1;
             }
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+                    LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0;
             lfsr_data_t data;
 
             // double check
@@ -2150,7 +2150,7 @@ 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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(name, 4)))) => 0;
             lfsr_data_t data;
 
             // double check
@@ -2179,7 +2179,7 @@ code = '''
                 mdir.rbyd.eoff = -1;
             }
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
         }
     }
 
@@ -2249,7 +2249,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2257,7 +2257,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0c", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2266,7 +2266,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0b", 2)))) => 0;
     assert(mdir.rbyd.weight == 4);
     lfsr_data_t data;
 
@@ -2308,7 +2308,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2316,7 +2316,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0b", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2325,7 +2325,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // assert neighbor was removed
@@ -2358,7 +2358,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2366,7 +2366,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0b", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2375,7 +2375,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // assert neighbor was removed
@@ -2410,7 +2410,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2418,7 +2418,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0d", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2430,14 +2430,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -2483,7 +2483,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2491,7 +2491,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0e", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2503,14 +2503,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -2522,7 +2522,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     // force mdir to compact
@@ -2568,7 +2568,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2576,7 +2576,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0b", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2626,7 +2626,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2634,7 +2634,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0d", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2646,14 +2646,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -2672,10 +2672,10 @@ code = '''
     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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -2715,7 +2715,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2723,7 +2723,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0d", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2735,14 +2735,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'c', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -2761,10 +2761,10 @@ code = '''
     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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_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_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0);
 
@@ -2802,7 +2802,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2810,7 +2810,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0f", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2822,14 +2822,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'e', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -2841,7 +2841,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     // force mdir to compact
@@ -2858,7 +2858,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mdir to compact
@@ -2904,7 +2904,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(left.mdir.rbyd.weight == 2);
     lfsr_opened_add(&lfs, &left);
 
@@ -2912,7 +2912,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0e", 2)))) => 0;
     assert(right.mdir.rbyd.weight == 3);
     lfsr_opened_add(&lfs, &right);
 
@@ -2924,14 +2924,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     memset(buffer+1, 'd', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 5);
 
     // force mroot to compact
@@ -2943,7 +2943,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 4);
 
     // force mdir to compact
@@ -2957,7 +2957,7 @@ code = '''
 
     // 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(mdir.rbyd.weight == 0);
 
     // assert mdir was dropped correctly
@@ -3002,7 +3002,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // test that we can traverse the tree, keeping track of all blocks we see
@@ -3102,13 +3102,13 @@ code = '''
     uint8_t buffer[SIZE];
     memset(buffer, 'a', SIZE);
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
 
     memset(buffer, 'b', SIZE);
     lfsr_mdir_t mdir;
     lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0;
     lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0;
+            LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
 
     // force mroot to compact
     lfs.mroot.rbyd.eoff = -1;
@@ -3236,14 +3236,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -3376,14 +3376,14 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     memset(buffer+1, 'b', SIZE-1);
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 3);
 
     // force mroot to compact
@@ -3400,7 +3400,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mdir to compact
@@ -3541,7 +3541,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
@@ -3660,7 +3660,7 @@ code = '''
             mdir.rbyd.eoff = -1;
         }
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0;
         lfsr_data_t data;
 
         uint8_t buffer[256];
@@ -3808,7 +3808,7 @@ code = '''
             mdir.rbyd.eoff = -1;
         }
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
-                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0;
+                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0;
         lfsr_data_t data;
 
         // double check
@@ -3942,7 +3942,7 @@ code = '''
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_MROOT, 0,
-                LFSR_DATA_FROMMPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0;
+                LFSR_CAT_MPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0;
 
     // technically, cycle detection only needs to work when we're validating
     lfsr_traversal_t traversal = LFSR_TRAVERSAL(LFSR_TRAVERSAL_VALIDATE);
@@ -4020,7 +4020,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
@@ -4077,7 +4077,7 @@ code = '''
     lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(buffer, SIZE)))) => 0;
     assert(mdir.rbyd.weight == 2);
 
     // force mroot to compact twice, this should extend the mroot
diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml
index 3af13ddc..ad843a1c 100644
--- a/tests/test_rbyd.toml
+++ b/tests/test_rbyd.toml
@@ -34,7 +34,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 
     // commit with two attributes
@@ -43,10 +43,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 '''
 
@@ -71,7 +71,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 
     // commit with two attributes
@@ -80,11 +80,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 '''
 
@@ -109,7 +109,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     // fetch
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -118,7 +118,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
 '''
 
@@ -151,7 +151,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -176,10 +176,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -214,10 +214,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -271,7 +271,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -296,11 +296,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -335,11 +335,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -392,7 +392,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
@@ -413,10 +413,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
@@ -439,10 +439,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
@@ -482,7 +482,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
@@ -503,11 +503,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
@@ -530,11 +530,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0;
     lfsr_data_read(&lfs, &data, buffer, 4) => 4;
     lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0;
@@ -578,10 +578,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -604,10 +604,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -649,13 +649,13 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -678,13 +678,13 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -728,13 +728,13 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -764,13 +764,13 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -819,16 +819,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -858,16 +858,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -897,16 +897,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -936,16 +936,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -996,16 +996,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1042,16 +1042,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1088,16 +1088,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1134,16 +1134,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1199,16 +1199,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1245,16 +1245,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1291,16 +1291,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1337,16 +1337,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1404,19 +1404,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1455,19 +1455,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1504,19 +1504,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1553,19 +1553,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1625,19 +1625,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1683,19 +1683,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1739,19 +1739,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1795,19 +1795,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1872,22 +1872,22 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1933,22 +1933,22 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -1994,22 +1994,22 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -2076,22 +2076,22 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xff\xff\xff\xff", 4)))) => 0;
+                LFSR_CAT_BUF("\xff\xff\xff\xff", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -2142,22 +2142,22 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xff\xff\xff\xff", 4)),
+                LFSR_CAT_BUF("\xff\xff\xff\xff", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -2208,22 +2208,22 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xff\xff\xff\xff", 4)),
+                LFSR_CAT_BUF("\xff\xff\xff\xff", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -2308,7 +2308,7 @@ code = '''
         for (unsigned j = 0; j < N; j++) {
             attrs[j] = LFSR_ATTR(
                     LFSR_TAG_UATTR(perm[j]+1), 0,
-                    LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4));
+                    LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4));
         }
 
         // test the given permutation
@@ -2401,7 +2401,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(perm[j]+1), 0,
-                        LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                        LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -2461,10 +2461,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -2499,10 +2499,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -2558,11 +2558,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -2597,11 +2597,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -2677,7 +2677,7 @@ code = '''
         for (unsigned j = 0; j < N; j++) {
             attrs[j] = LFSR_ATTR(
                     LFSR_TAG_UATTR(perm[j]+1), 0,
-                    LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4));
+                    LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4));
         }
 
         // test the given permutation
@@ -2752,7 +2752,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(perm[j]+1), 0,
-                        LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                        LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -2809,7 +2809,7 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(j+1), 0,
-                    LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                    LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     }
 
     // copy block so we can reset after each remove
@@ -2851,7 +2851,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(perm[j]+1), 0,
-                        LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
+                        LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
         }
 
         // check that all tags have been updated
@@ -2930,7 +2930,7 @@ code = '''
         int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(x & 0x7f), 0,
-                    LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4))));
+                    LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4))));
         if (err == LFS_ERR_RANGE) {
             break;
         }
@@ -2982,11 +2982,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -3005,14 +3005,14 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -3047,14 +3047,14 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -3134,7 +3134,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(perm[j]+1), 0,
-                        LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                        LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
 
         // copy block so we can reset after each remove
@@ -3159,7 +3159,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_UATTR(j+1), 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
@@ -3188,7 +3188,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(j+1), 0,
-                        LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
+                        LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
@@ -3284,7 +3284,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(perm[j]+1), 0,
-                        LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                        LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
         }
 
         // copy block so we can reset after each remove
@@ -3309,7 +3309,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_UATTR(j+1), 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -3363,10 +3363,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3394,7 +3394,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3421,7 +3421,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3448,7 +3448,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3522,30 +3522,30 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
     // remove several attributes
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
@@ -3574,7 +3574,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3601,7 +3601,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3628,7 +3628,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3657,7 +3657,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3684,7 +3684,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3711,7 +3711,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => 0;
     assert(tag_ == LFSR_TAG_UATTR(2));
@@ -3785,11 +3785,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -3808,17 +3808,17 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -3837,17 +3837,17 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
             &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT;
@@ -3899,7 +3899,7 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(j+1), 0,
-                    LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                    LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     }
 
     // copy block so we can reset after each remove
@@ -3941,7 +3941,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_UATTR(perm[j]+1), 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
         }
 
         // check that all tags are now removed
@@ -3955,7 +3955,7 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(1), 0,
-                    LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
+                    LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
         lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1),
@@ -4053,7 +4053,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(attr), 0,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         } else {
             // update our sim
             sim[attr] = '\0';
@@ -4061,7 +4061,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_UATTR(attr), 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
         }
     }
 
@@ -4137,7 +4137,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4156,10 +4156,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4184,13 +4184,13 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4239,7 +4239,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4258,11 +4258,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4287,11 +4287,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4316,15 +4316,15 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4355,15 +4355,15 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4394,15 +4394,15 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4497,7 +4497,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -4559,10 +4559,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -4632,11 +4632,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -4683,11 +4683,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -4797,7 +4797,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -4868,7 +4868,7 @@ code = '''
         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))));
+                LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(names[x % 6], 4))));
         if (err == LFS_ERR_RANGE) {
             break;
         }
@@ -4917,10 +4917,10 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4945,16 +4945,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -4991,22 +4991,22 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)),
+                LFSR_CAT_BUF("\xbb\xbb",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -5096,11 +5096,11 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -5125,19 +5125,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -5174,19 +5174,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -5223,27 +5223,27 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -5315,27 +5315,27 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -5384,27 +5384,27 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -5518,13 +5518,13 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
             // note uattrs 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_TAG_UATTR(u+1), 0,
-                            LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                            LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
             }
         }
 
@@ -5593,16 +5593,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -5704,19 +5704,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -5795,19 +5795,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
             &rid_, &tag_, NULL, &data_) => 0;
@@ -5950,13 +5950,13 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
             // note uattrs 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_TAG_UATTR(u+1), 0,
-                            LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                            LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
             }
         }
 
@@ -6040,13 +6040,13 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_REG, +1,
-                    LFSR_DATA_BUF(names[j % 6], 4)))) => 0;
+                    LFSR_CAT_BUF(names[j % 6], 4)))) => 0;
         // note uattrs 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_TAG_UATTR(u+1), 0,
-                        LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 2)))) => 0;
         }
     }
 
@@ -6089,7 +6089,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(perm[j]%M+1), 0,
-                        LFSR_DATA_BUF(names[(perm[j]/M) % 6], 3)))) => 0;
+                        LFSR_CAT_BUF(names[(perm[j]/M) % 6], 3)))) => 0;
         }
 
         // check that all tags have been updated
@@ -6207,13 +6207,13 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
             // note uattrs 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_TAG_UATTR(u+1), 0,
-                            LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                            LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
             }
         }
 
@@ -6239,7 +6239,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_UATTR((j%M)+1), 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
@@ -6283,7 +6283,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((j%M)+1), 0,
-                        LFSR_DATA_BUF(names[(j/M)%6], 3)))) => 0;
+                        LFSR_CAT_BUF(names[(j/M)%6], 3)))) => 0;
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
@@ -6387,13 +6387,13 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_REG, +1,
-                    LFSR_DATA_BUF(names[j % 6], 4)))) => 0;
+                    LFSR_CAT_BUF(names[j % 6], 4)))) => 0;
         // note uattrs 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_TAG_UATTR(u+1), 0,
-                        LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 2)))) => 0;
         }
     }
 
@@ -6436,7 +6436,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_UATTR(perm[j]%M+1), 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
         }
 
         // check that all tags have been removed
@@ -6527,11 +6527,11 @@ code = '''
         // build a single attribute list with all attributes, 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));
+        attrs[0] = LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(names[x % 6], 4));
         for (unsigned u = 0; u < M; u++) {
             attrs[1+u] = LFSR_ATTR(
                     LFSR_TAG_UATTR(u+1), 0,
-                    LFSR_DATA_BUF(names[x % 6], 2));
+                    LFSR_CAT_BUF(names[x % 6], 2));
         }
 
         int err = lfsr_rbyd_commit(&lfs, &rbyd, x, attrs, 1+M);
@@ -6638,12 +6638,12 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(perm[j]+1), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
         // try looking up each tag
@@ -6784,17 +6784,17 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(perm[j]+1), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_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_TAG_UATTR(u+1), 0,
-                            LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                            LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
             }
         }
 
@@ -6909,12 +6909,12 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -6937,12 +6937,12 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -6965,15 +6965,15 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7000,15 +7000,15 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7035,15 +7035,15 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7088,18 +7088,18 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7132,18 +7132,18 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 1);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7176,24 +7176,24 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)),
+                LFSR_CAT_BUF("\xbb\xbb",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7238,24 +7238,24 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)),
+                LFSR_CAT_BUF("\xbb\xbb",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7300,24 +7300,24 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)),
+                LFSR_CAT_BUF("\xbb\xbb",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7390,65 +7390,65 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_BUF("\xee\xee",         2)))) => 0;
 
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7551,7 +7551,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7688,59 +7688,59 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), +1,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_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_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,       0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7831,7 +7831,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -7956,87 +7956,87 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), +1,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_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_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(8), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,      0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(8), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_BUF("\xee\xee",         2)))) => 0;
 
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -8163,7 +8163,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -8327,75 +8327,75 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), +1,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(8), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(9), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(9), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(9), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_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_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,      0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_REG,      0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -8516,7 +8516,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -8674,75 +8674,75 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(9), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), +1,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_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_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(8), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(8), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
 
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -8863,7 +8863,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9021,76 +9021,76 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), +1,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_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_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,      0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
 
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9199,7 +9199,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9345,76 +9345,76 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), +1,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), +1,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_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_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,      0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_REG,      0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9523,7 +9523,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9671,117 +9671,117 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), +1,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_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_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(8), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(11), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(12), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,       0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_REG,       0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(13), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(14), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(9), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(10), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(10), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
 
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -9932,7 +9932,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -10122,115 +10122,115 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)),
+                LFSR_CAT_BUF("\xcc\xcc",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(6), +1,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(7), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(8), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(9), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(10), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow to the root
             LFSR_ATTR(
                 LFSR_TAG_UATTR(10), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(10), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(10), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_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_TAG_UATTR(11), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(12), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(13), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(14),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(14),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(14),  0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_BUF("\xee\xee",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_BUF("\xee\xee",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,      0,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(5), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)),
+                LFSR_CAT_BUF("\xee\xee",         2)),
             // propagate yellow
             LFSR_ATTR(
                 LFSR_TAG_UATTR(4), 0,
-                LFSR_DATA_BUF("\xee\xee",         2)))) => 0;
+                LFSR_CAT_BUF("\xee\xee",         2)))) => 0;
 
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 2);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -10381,7 +10381,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,    +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     assert(rbyd.weight == 3);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0;
@@ -10607,7 +10607,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -10631,7 +10631,7 @@ code = '''
                     NULL) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -10653,7 +10653,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -10769,13 +10769,13 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
             // note uattrs 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_TAG_UATTR(u+1), 0,
-                            LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                            LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
             }
         }
         assert(rbyd.weight == N);
@@ -10800,7 +10800,7 @@ code = '''
                     NULL) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -10835,12 +10835,12 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 6)))) => 0;
             for (unsigned u = 0; u < M; u++) {
                 lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                         LFSR_ATTR(
                             LFSR_TAG_UATTR(u+1), 0,
-                            LFSR_DATA_BUF(names[j % 6], 3)))) => 0;
+                            LFSR_CAT_BUF(names[j % 6], 3)))) => 0;
             }
             assert(rbyd.weight == N);
 
@@ -10969,7 +10969,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -10993,7 +10993,7 @@ code = '''
                     NULL) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
             // try traversing over the tags
@@ -11099,13 +11099,13 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
             // note uattrs 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_TAG_UATTR(u+1), 0,
-                            LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                            LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
             }
         }
         assert(rbyd.weight == N);
@@ -11130,7 +11130,7 @@ code = '''
                     NULL) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == N-1);
 
             // try traversing over the tags
@@ -11204,9 +11204,9 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11223,13 +11223,13 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()),
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11246,14 +11246,14 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11270,17 +11270,17 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()),
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()),
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11297,19 +11297,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11344,12 +11344,12 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11366,19 +11366,19 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()),
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11395,20 +11395,20 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11425,26 +11425,26 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)),
+                LFSR_CAT_BUF("\xbb\xbb",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()),
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()),
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11461,28 +11461,28 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa",         2)),
+                LFSR_CAT_BUF("\xaa\xaa",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb",         2)),
+                LFSR_CAT_BUF("\xbb\xbb",         2)),
             LFSR_ATTR(
                 LFSR_TAG_REG,     +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc",         2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc",         2)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
-            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
+            LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
 
     assert(rbyd.weight == 0);
     lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG,
@@ -11539,7 +11539,7 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_REG, +1,
-                    LFSR_DATA_BUF(names[j % 6], 4)))) => 0;
+                    LFSR_CAT_BUF(names[j % 6], 4)))) => 0;
     }
     assert(rbyd.weight == N);
 
@@ -11589,7 +11589,7 @@ 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == rbyd_weight_before-1);
         }
 
@@ -11604,7 +11604,7 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_REG, +1,
-                    LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
+                    LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
         assert(rbyd.weight == 1);
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -11688,13 +11688,13 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_REG, +1,
-                    LFSR_DATA_BUF(names[j % 6], 4)))) => 0;
+                    LFSR_CAT_BUF(names[j % 6], 4)))) => 0;
         // note uattrs 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_TAG_UATTR(u+1), 0,
-                        LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 2)))) => 0;
         }
     }
     assert(rbyd.weight == N);
@@ -11745,7 +11745,7 @@ 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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == rbyd_weight_before-1);
         }
 
@@ -11760,12 +11760,12 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_REG, +1,
-                    LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0;
+                    LFSR_CAT_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_TAG_UATTR(u+1), 0,
-                        LFSR_DATA_BUF("\xaa\xaa\xaa", 3)))) => 0;
+                        LFSR_CAT_BUF("\xaa\xaa\xaa", 3)))) => 0;
         }
         assert(rbyd.weight == 1);
 
@@ -11880,14 +11880,14 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         } else {
             // update our sim
             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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
         }
     }
 
@@ -11954,7 +11954,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -11975,7 +11975,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +2,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -12008,7 +12008,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +3,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -12053,7 +12053,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +4,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -12110,7 +12110,7 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +5,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG,
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -12201,23 +12201,23 @@ code = '''
             // make id0 with weight w1
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             // make id2 with weight w2
             LFSR_ATTR(
                 LFSR_TAG_REG, +2,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             // make id5 with weight w3
             LFSR_ATTR(
                 LFSR_TAG_REG, +3,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             // make id9 with weight w4
             LFSR_ATTR(
                 LFSR_TAG_REG, +4,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             // make id14 with weight w5
             LFSR_ATTR(
                 LFSR_TAG_REG, +5,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0;
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0;
 
     // traverse, finding tags and weights
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
@@ -12358,7 +12358,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -12448,7 +12448,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -12499,16 +12499,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("unrelated", 9)),
+                LFSR_CAT_BUF("unrelated", 9)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa", 2)),
+                LFSR_CAT_BUF("\xaa\xaa", 2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0;
+                LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -12565,16 +12565,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb", 2)),
+                LFSR_CAT_BUF("\xbb\xbb", 2)),
             LFSR_ATTR(
                 LFSR_TAG_GROW, +1,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0;
+                LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -12667,16 +12667,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc", 2)),
+                LFSR_CAT_BUF("\xcc\xcc", 2)),
             LFSR_ATTR(
                 LFSR_TAG_GROW, +2,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -12805,16 +12805,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xdd\xdd", 2)),
+                LFSR_CAT_BUF("\xdd\xdd", 2)),
             LFSR_ATTR(
                 LFSR_TAG_GROW, +3,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xdd\xdd", 2)))) => 0;
+                LFSR_CAT_BUF("\xdd\xdd", 2)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -12979,16 +12979,16 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee", 2)),
+                LFSR_CAT_BUF("\xee\xee", 2)),
             LFSR_ATTR(
                 LFSR_TAG_GROW, +4,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xee\xee", 2)))) => 0;
+                LFSR_CAT_BUF("\xee\xee", 2)))) => 0;
 
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3),
             &rid_, &tag_, &weight_, &data_) => 0;
@@ -13210,69 +13210,69 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(3), 0,
-                LFSR_DATA_BUF("unrelated", 9)),
+                LFSR_CAT_BUF("unrelated", 9)),
             // make id0 with weight w1
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xaa\xaa", 2)),
+                LFSR_CAT_BUF("\xaa\xaa", 2)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xaa\xaa", 2)),
+                LFSR_CAT_BUF("\xaa\xaa", 2)),
             // make id2 with weight w2
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb", 2)),
+                LFSR_CAT_BUF("\xbb\xbb", 2)),
             LFSR_ATTR(
                 LFSR_TAG_GROW, +1,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xbb\xbb", 2)),
+                LFSR_CAT_BUF("\xbb\xbb", 2)),
             // make id5 with weight w3
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xcc\xcc", 2)),
+                LFSR_CAT_BUF("\xcc\xcc", 2)),
             LFSR_ATTR(
                 LFSR_TAG_GROW, +2,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xcc\xcc", 2)),
+                LFSR_CAT_BUF("\xcc\xcc", 2)),
             // make id9 with weight w4
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xdd\xdd", 2)),
+                LFSR_CAT_BUF("\xdd\xdd", 2)),
             LFSR_ATTR(
                 LFSR_TAG_GROW, +3,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xdd\xdd", 2)),
+                LFSR_CAT_BUF("\xdd\xdd", 2)),
             // make id14 with weight w5
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xee\xee\xee\xee", 4)),
+                LFSR_CAT_BUF("\xee\xee\xee\xee", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xee\xee", 2)),
+                LFSR_CAT_BUF("\xee\xee", 2)),
             LFSR_ATTR(
                 LFSR_TAG_GROW, +4,
-                LFSR_DATA_NULL()),
+                LFSR_CAT_NULL()),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xee\xee", 2)))) => 0;
+                LFSR_CAT_BUF("\xee\xee", 2)))) => 0;
 
     // traverse, finding tags and weights
     lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0,
@@ -13536,7 +13536,7 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(3), 0,
-                    LFSR_DATA_BUF("unrelated", 9)))) => 0;
+                    LFSR_CAT_BUF("unrelated", 9)))) => 0;
 
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
@@ -13550,16 +13550,16 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(1), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)),
                     LFSR_ATTR(
                         LFSR_TAG_GROW, +W-1,
-                        LFSR_DATA_NULL()),
+                        LFSR_CAT_NULL()),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(2), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
         }
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -13658,7 +13658,7 @@ code = '''
         lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
                 LFSR_ATTR(
                     LFSR_TAG_UATTR(3), 0,
-                    LFSR_DATA_BUF("unrelated", 9)))) => 0;
+                    LFSR_CAT_BUF("unrelated", 9)))) => 0;
 
         for (unsigned j = 0; j < N; j++) {
             // adjust rid based on future insertions
@@ -13672,16 +13672,16 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(1), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)),
                     LFSR_ATTR(
                         LFSR_TAG_GROW, +W-1,
-                        LFSR_DATA_NULL()),
+                        LFSR_CAT_NULL()),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(2), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
         }
 
         lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
@@ -13799,7 +13799,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N*W);
 
@@ -13823,7 +13823,7 @@ code = '''
                     NULL) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_GROW, +D, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == N*W+D);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -13931,7 +13931,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N*W);
 
@@ -13957,7 +13957,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_GROW | LFSR_TAG_REG, +D,
-                        LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W+D);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14075,7 +14075,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(2), +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N*W);
 
@@ -14101,7 +14101,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_GROW | LFSR_TAG_UATTR(1), +D,
-                        LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W+D);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14232,7 +14232,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N*W);
 
@@ -14256,7 +14256,7 @@ code = '''
                     NULL) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_GROW, -D, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == N*W-D);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14364,7 +14364,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N*W);
 
@@ -14390,7 +14390,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_GROW | LFSR_TAG_REG, -D,
-                        LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W-D);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14508,7 +14508,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(2), +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N*W);
 
@@ -14534,7 +14534,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_GROW | LFSR_TAG_UATTR(1), -D,
-                        LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W-D);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14664,7 +14664,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N*W);
 
@@ -14688,7 +14688,7 @@ code = '''
                     NULL) => 0;
 
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
-                    LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0;
+                    LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == (N-1)*W);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14724,7 +14724,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 6)))) => 0;
             assert(rbyd.weight == N*W);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14828,7 +14828,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +W,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N*W);
 
@@ -14855,7 +14855,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(1), 0,
-                        LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 2)))) => 0;
             assert(rbyd.weight == N*W);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14888,7 +14888,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
             assert(rbyd.weight == N*W);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -14916,7 +14916,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(1), 0,
-                        LFSR_DATA_BUF(names[j % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 2)))) => 0;
             assert(rbyd.weight == N*W);
 
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -15029,14 +15029,14 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         } else if (op == 1) {
             // update our sim
             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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
         } else if (op == 2) {
             // update our sim
             sim[rid*(M+1) + u+1] = 'a'+(i % 26);
@@ -15044,7 +15044,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR(u), 0,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
 
         } else if (op == 3) {
             // update our sim
@@ -15053,7 +15053,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_UATTR(u), 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
         }
     }
 
@@ -15203,7 +15203,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +weight,
-                        LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
+                        LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0;
         } else if (op == 1) {
             // get the correct weight from the sim
             weight_ = sim_weights[rid];
@@ -15214,7 +15214,7 @@ code = '''
             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_ATTR(LFSR_TAG_RM, -weight_, LFSR_CAT_NULL()))) => 0;
         } else if (op == 2) {
             // get the correct weight from the sim
             weight_ = sim_weights[rid];
@@ -15222,7 +15222,7 @@ code = '''
             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_ATTR(LFSR_TAG_GROW, +weight, LFSR_CAT_NULL()))) => 0;
         } else if (op == 3) {
             // get the correct weight from the sim
             weight_ = sim_weights[rid];
@@ -15233,7 +15233,7 @@ code = '''
             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_ATTR(LFSR_TAG_GROW, -weight, LFSR_CAT_NULL()))) => 0;
         }
     }
 
@@ -15367,10 +15367,10 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -15457,10 +15457,10 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -15487,7 +15487,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_UATTR, 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -15601,10 +15601,10 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -15632,7 +15632,7 @@ code = '''
                     LFSR_ATTR(
                         LFSR_TAG_SUB | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f),
                             0,
-                        LFSR_DATA_BUF(names[j % 6], 3)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 3)))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -15747,13 +15747,13 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)),
                     LFSR_ATTR(
                         LFSR_TAG_SATTR(0), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -15840,13 +15840,13 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)),
                     LFSR_ATTR(
                         LFSR_TAG_SATTR(0), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -15873,7 +15873,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_UATTR, 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -15994,13 +15994,13 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)),
                     LFSR_ATTR(
                         LFSR_TAG_SATTR(0), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -16028,7 +16028,7 @@ code = '''
                     LFSR_ATTR(
                         LFSR_TAG_SUB | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f),
                             0,
-                        LFSR_DATA_BUF(names[j % 6], 3)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 3)))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -16150,7 +16150,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -16237,7 +16237,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -16264,7 +16264,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_UATTR, 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -16381,7 +16381,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -16409,7 +16409,7 @@ code = '''
                     LFSR_ATTR(
                         LFSR_TAG_SUB | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f),
                             0,
-                        LFSR_DATA_BUF(names[j % 6], 6)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 6)))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -16518,10 +16518,10 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -16608,10 +16608,10 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -16638,7 +16638,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_RM | LFSR_TAG_SUP | LFSR_TAG_UATTR, 0,
-                        LFSR_DATA_NULL()))) => 0;
+                        LFSR_CAT_NULL()))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -16752,10 +16752,10 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS(
                     LFSR_ATTR(
                         LFSR_TAG_REG, +1,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 4)),
+                        LFSR_CAT_BUF(names[perm[j] % 6], 4)),
                     LFSR_ATTR(
                         LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0,
-                        LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0;
+                        LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0;
         }
         assert(rbyd.weight == N);
 
@@ -16783,7 +16783,7 @@ code = '''
                     LFSR_ATTR(
                         LFSR_TAG_SUP | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f),
                             0,
-                        LFSR_DATA_BUF(names[j % 6], 3)))) => 0;
+                        LFSR_CAT_BUF(names[j % 6], 3)))) => 0;
 
             // try traversing over the tags
             lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
@@ -16864,13 +16864,13 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     assert(rbyd.weight == 0);
 
     // can we still access things?
@@ -16912,23 +16912,23 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)),
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)),
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     assert(rbyd.weight == 0);
 
     // remove a neighbor to the hole
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     assert(rbyd.weight == 0);
 
     // can we still access things?
@@ -16970,22 +16970,22 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_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_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0;
     assert(rbyd.weight == 1);
 
     // can we still access things?
@@ -17027,23 +17027,23 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_SATTR(0), 0,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)),
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)),
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     assert(rbyd.weight == 0);
 
     // subwide replace a neighbor to the hole
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUB | LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     assert(rbyd.weight == 0);
 
     // can we still access things?
@@ -17094,24 +17094,24 @@ code = '''
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)),
+                LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)),
             LFSR_ATTR(
                 LFSR_TAG_UATTR(1), 0,
-                LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)),
+                LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)),
             LFSR_ATTR(
                 LFSR_TAG_REG, +1,
-                LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
+                LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0;
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0,
-                LFSR_DATA_NULL()))) => 0;
+                LFSR_CAT_NULL()))) => 0;
     assert(rbyd.weight == 1);
 
     // supwide replace a neighbor to the hole
     lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_SUP | LFSR_TAG_UATTR(2), 0,
-                LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
+                LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0;
     assert(rbyd.weight == 1);
 
     // can we still access things?