diff --git a/benches/bench_btree.toml b/benches/bench_btree.toml
index 3c7289cd..59742673 100644
--- a/benches/bench_btree.toml
+++ b/benches/bench_btree.toml
@@ -15,12 +15,12 @@ defines.SEED = 42
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -66,12 +66,12 @@ defines.AMORTIZED = false
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
diff --git a/benches/bench_mtree.toml b/benches/bench_mtree.toml
index 0dc748a7..58bba5c4 100644
--- a/benches/bench_mtree.toml
+++ b/benches/bench_mtree.toml
@@ -18,8 +18,8 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     // create an mtree with N entries
@@ -80,8 +80,8 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     // create an mtree with N entries
@@ -152,8 +152,8 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     // create an mtree with N entries
diff --git a/benches/bench_rbyd.toml b/benches/bench_rbyd.toml
index cb811a89..819dbc81 100644
--- a/benches/bench_rbyd.toml
+++ b/benches/bench_rbyd.toml
@@ -18,7 +18,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*N <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -59,7 +59,7 @@ code = '''
     }
     BENCH_STOP();
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 '''
 
 [cases.bench_rbyd_attr_fetch]
@@ -75,7 +75,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*N <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -115,7 +115,7 @@ code = '''
     }
 
     BENCH_START();
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
     BENCH_STOP();
 '''
 
@@ -132,7 +132,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*N <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -171,7 +171,7 @@ code = '''
         }
     }
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 
     BENCH_START();
     lfs_off_t i_ = BENCH_PRNG(&prng) % N;
@@ -196,7 +196,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*(N+1) <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -235,7 +235,7 @@ code = '''
         }
     }
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 
     BENCH_START();
     lfs_off_t i_ = BENCH_PRNG(&prng) % N;
@@ -262,7 +262,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*(N+1) <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -301,7 +301,7 @@ code = '''
         }
     }
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 
     BENCH_START();
     lfs_off_t i_ = BENCH_PRNG(&prng) % N;
@@ -327,7 +327,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*N <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -364,7 +364,7 @@ code = '''
     }
     BENCH_STOP();
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 '''
 
 [cases.bench_rbyd_id_fetch]
@@ -380,7 +380,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*N <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -416,7 +416,7 @@ code = '''
     }
 
     BENCH_START();
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
     BENCH_STOP();
 '''
 
@@ -433,7 +433,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*N <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -468,7 +468,7 @@ code = '''
         }
     }
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 
     BENCH_START();
     lfs_off_t i_ = BENCH_PRNG(&prng) % N;
@@ -491,7 +491,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*(N+1) <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -526,7 +526,7 @@ code = '''
         }
     }
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 
     BENCH_START();
     lfs_off_t i_ = BENCH_PRNG(&prng) % (N+1);
@@ -552,7 +552,7 @@ in = 'lfs.c'
 if = 'COMMIT == 0 || PROG_SIZE*(N+1) <= BLOCK_SIZE'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t rbyd = {
         .block = 0,
@@ -587,7 +587,7 @@ code = '''
         }
     }
 
-    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+    lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 
     BENCH_START();
     lfs_off_t i_ = BENCH_PRNG(&prng) % N;
diff --git a/scripts/bench.py b/scripts/bench.py
index a3ed0ec9..cea7b075 100755
--- a/scripts/bench.py
+++ b/scripts/bench.py
@@ -405,7 +405,7 @@ def compile(bench_paths, **args):
 
                     # create case run function
                     f.writeln('void __bench__%s__run('
-                        '__attribute__((unused)) struct lfs_config *cfg) {'
+                        '__attribute__((unused)) struct lfs_config *CFG) {'
                         % (case.name))
                     f.writeln(4*' '+'// bench case %s' % case.name)
                     if case.code_lineno is not None:
@@ -454,7 +454,7 @@ def compile(bench_paths, **args):
                                 'void);'
                                 % (case.name))
                         f.writeln('extern void __bench__%s__run('
-                            'struct lfs_config *cfg);'
+                            'struct lfs_config *CFG);'
                             % (case.name))
                         f.writeln()
 
diff --git a/scripts/test.py b/scripts/test.py
index 9ebfe24e..c3eea164 100755
--- a/scripts/test.py
+++ b/scripts/test.py
@@ -410,7 +410,7 @@ def compile(test_paths, **args):
 
                     # create case run function
                     f.writeln('void __test__%s__run('
-                        '__attribute__((unused)) struct lfs_config *cfg) {'
+                        '__attribute__((unused)) struct lfs_config *CFG) {'
                         % (case.name))
                     f.writeln(4*' '+'// test case %s' % case.name)
                     if case.code_lineno is not None:
@@ -459,7 +459,7 @@ def compile(test_paths, **args):
                                 'void);'
                                 % (case.name))
                         f.writeln('extern void __test__%s__run('
-                            'struct lfs_config *cfg);'
+                            'struct lfs_config *CFG);'
                             % (case.name))
                         f.writeln()
 
diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml
index 9018a638..a1bc57d2 100644
--- a/tests/test_alloc.toml
+++ b/tests/test_alloc.toml
@@ -11,8 +11,8 @@ after = 'test_mtree'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // start allocating
     lfs_alloc_ack(&lfs);
@@ -44,8 +44,8 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // start allocating
     lfs_alloc_ack(&lfs);
@@ -101,8 +101,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now 
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
diff --git a/tests/test_bd.toml b/tests/test_bd.toml
index 98f54df3..d87ea33f 100644
--- a/tests/test_bd.toml
+++ b/tests/test_bd.toml
@@ -13,17 +13,17 @@ code = '''
     uint8_t buffer[lfs_max(READ, PROG)];
 
     // write data
-    cfg->erase(cfg, 0) => 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
+    CFG->erase(CFG, 0) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) {
         for (lfs_off_t j = 0; j < PROG; j++) {
             buffer[j] = (i+j) % 251;
         }
-        cfg->prog(cfg, 0, i, buffer, PROG) => 0;
+        CFG->prog(CFG, 0, i, buffer, PROG) => 0;
     }
 
     // read data
-    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-        cfg->read(cfg, 0, i, buffer, READ) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+        CFG->read(CFG, 0, i, buffer, READ) => 0;
 
         for (lfs_off_t j = 0; j < READ; j++) {
             LFS_ASSERT(buffer[j] == (i+j) % 251);
@@ -40,18 +40,18 @@ code = '''
 
     // write block 0
     block = 0;
-    cfg->erase(cfg, block) => 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
+    CFG->erase(CFG, block) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) {
         for (lfs_off_t j = 0; j < PROG; j++) {
             buffer[j] = (block+i+j) % 251;
         }
-        cfg->prog(cfg, block, i, buffer, PROG) => 0;
+        CFG->prog(CFG, block, i, buffer, PROG) => 0;
     }
 
     // read block 0
     block = 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-        cfg->read(cfg, block, i, buffer, READ) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+        CFG->read(CFG, block, i, buffer, READ) => 0;
 
         for (lfs_off_t j = 0; j < READ; j++) {
             LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -60,18 +60,18 @@ code = '''
 
     // write block 1
     block = 1;
-    cfg->erase(cfg, block) => 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
+    CFG->erase(CFG, block) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) {
         for (lfs_off_t j = 0; j < PROG; j++) {
             buffer[j] = (block+i+j) % 251;
         }
-        cfg->prog(cfg, block, i, buffer, PROG) => 0;
+        CFG->prog(CFG, block, i, buffer, PROG) => 0;
     }
 
     // read block 1
     block = 1;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-        cfg->read(cfg, block, i, buffer, READ) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+        CFG->read(CFG, block, i, buffer, READ) => 0;
 
         for (lfs_off_t j = 0; j < READ; j++) {
             LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -80,8 +80,8 @@ code = '''
 
     // read block 0 again
     block = 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-        cfg->read(cfg, block, i, buffer, READ) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+        CFG->read(CFG, block, i, buffer, READ) => 0;
 
         for (lfs_off_t j = 0; j < READ; j++) {
             LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -98,18 +98,18 @@ code = '''
 
     // write block 0
     block = 0;
-    cfg->erase(cfg, block) => 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
+    CFG->erase(CFG, block) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) {
         for (lfs_off_t j = 0; j < PROG; j++) {
             buffer[j] = (block+i+j) % 251;
         }
-        cfg->prog(cfg, block, i, buffer, PROG) => 0;
+        CFG->prog(CFG, block, i, buffer, PROG) => 0;
     }
 
     // read block 0
     block = 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-        cfg->read(cfg, block, i, buffer, READ) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+        CFG->read(CFG, block, i, buffer, READ) => 0;
 
         for (lfs_off_t j = 0; j < READ; j++) {
             LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -117,19 +117,19 @@ code = '''
     }
 
     // write block n-1
-    block = cfg->block_count-1;
-    cfg->erase(cfg, block) => 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
+    block = CFG->block_count-1;
+    CFG->erase(CFG, block) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) {
         for (lfs_off_t j = 0; j < PROG; j++) {
             buffer[j] = (block+i+j) % 251;
         }
-        cfg->prog(cfg, block, i, buffer, PROG) => 0;
+        CFG->prog(CFG, block, i, buffer, PROG) => 0;
     }
 
     // read block n-1
-    block = cfg->block_count-1;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-        cfg->read(cfg, block, i, buffer, READ) => 0;
+    block = CFG->block_count-1;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+        CFG->read(CFG, block, i, buffer, READ) => 0;
 
         for (lfs_off_t j = 0; j < READ; j++) {
             LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -138,8 +138,8 @@ code = '''
 
     // read block 0 again
     block = 0;
-    for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-        cfg->read(cfg, block, i, buffer, READ) => 0;
+    for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+        CFG->read(CFG, block, i, buffer, READ) => 0;
 
         for (lfs_off_t j = 0; j < READ; j++) {
             LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -155,19 +155,19 @@ code = '''
 
     // write/read every power of 2
     lfs_block_t block = 1;
-    while (block < cfg->block_count) {
+    while (block < CFG->block_count) {
         // write
-        cfg->erase(cfg, block) => 0;
-        for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
+        CFG->erase(CFG, block) => 0;
+        for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) {
             for (lfs_off_t j = 0; j < PROG; j++) {
                 buffer[j] = (block+i+j) % 251;
             }
-            cfg->prog(cfg, block, i, buffer, PROG) => 0;
+            CFG->prog(CFG, block, i, buffer, PROG) => 0;
         }
 
         // read
-        for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-            cfg->read(cfg, block, i, buffer, READ) => 0;
+        for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+            CFG->read(CFG, block, i, buffer, READ) => 0;
 
             for (lfs_off_t j = 0; j < READ; j++) {
                 LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -179,10 +179,10 @@ code = '''
 
     // read every power of 2 again
     block = 1;
-    while (block < cfg->block_count) {
+    while (block < CFG->block_count) {
         // read
-        for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-            cfg->read(cfg, block, i, buffer, READ) => 0;
+        for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+            CFG->read(CFG, block, i, buffer, READ) => 0;
 
             for (lfs_off_t j = 0; j < READ; j++) {
                 LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -202,19 +202,19 @@ code = '''
     // write/read every fibonacci number on our device
     lfs_block_t block = 1;
     lfs_block_t block_ = 1;
-    while (block < cfg->block_count) {
+    while (block < CFG->block_count) {
         // write
-        cfg->erase(cfg, block) => 0;
-        for (lfs_off_t i = 0; i < cfg->block_size; i += PROG) {
+        CFG->erase(CFG, block) => 0;
+        for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) {
             for (lfs_off_t j = 0; j < PROG; j++) {
                 buffer[j] = (block+i+j) % 251;
             }
-            cfg->prog(cfg, block, i, buffer, PROG) => 0;
+            CFG->prog(CFG, block, i, buffer, PROG) => 0;
         }
 
         // read
-        for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-            cfg->read(cfg, block, i, buffer, READ) => 0;
+        for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+            CFG->read(CFG, block, i, buffer, READ) => 0;
 
             for (lfs_off_t j = 0; j < READ; j++) {
                 LFS_ASSERT(buffer[j] == (block+i+j) % 251);
@@ -229,10 +229,10 @@ code = '''
     // read every fibonacci number again
     block = 1;
     block_ = 1;
-    while (block < cfg->block_count) {
+    while (block < CFG->block_count) {
         // read
-        for (lfs_off_t i = 0; i < cfg->block_size; i += READ) {
-            cfg->read(cfg, block, i, buffer, READ) => 0;
+        for (lfs_off_t i = 0; i < CFG->block_size; i += READ) {
+            CFG->read(CFG, block, i, buffer, READ) => 0;
 
             for (lfs_off_t j = 0; j < READ; j++) {
                 LFS_ASSERT(buffer[j] == (block+i+j) % 251);
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index 3d380600..a8274396 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -11,12 +11,12 @@ defines.LOOKAHEAD_SIZE = 'lfs_alignup(BLOCK_COUNT / 8, 8)'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -42,12 +42,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -81,12 +81,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -127,12 +127,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -174,12 +174,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -228,12 +228,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -285,12 +285,12 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -337,12 +337,12 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -392,12 +392,12 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -475,12 +475,12 @@ defines.W = 5
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -547,12 +547,12 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -685,12 +685,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -726,12 +726,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -777,12 +777,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -839,12 +839,12 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -913,12 +913,12 @@ code = '''
     const char *uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1007,12 +1007,12 @@ defines.W = 5
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1097,12 +1097,12 @@ code = '''
     const char *uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1246,12 +1246,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1299,12 +1299,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1366,12 +1366,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1433,12 +1433,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1517,12 +1517,12 @@ if = 'N > REMAINING'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1608,12 +1608,12 @@ if = 'N > REMAINING'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1701,12 +1701,12 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1798,12 +1798,12 @@ if = 'N > REMAINING'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -1918,12 +1918,12 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2077,12 +2077,12 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2136,12 +2136,12 @@ code = '''
     const char *uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2224,12 +2224,12 @@ defines.W = 5
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2284,12 +2284,12 @@ code = '''
     const char *uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2435,12 +2435,12 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2552,12 +2552,12 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2723,12 +2723,12 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2756,12 +2756,12 @@ defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2805,12 +2805,12 @@ defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2865,12 +2865,12 @@ in = 'lfs.c'
 defines.DID = [false, true]
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -2936,12 +2936,12 @@ defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -3008,12 +3008,12 @@ defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -3076,12 +3076,12 @@ code = '''
     const char *nums = "0123456789";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -3186,12 +3186,12 @@ defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -3255,12 +3255,12 @@ code = '''
     const char *nums = "0123456789";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -3406,12 +3406,12 @@ code = '''
     const char *nums = "0123456789";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -3581,12 +3581,12 @@ code = '''
     const char *nums = "0123456789";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -3802,12 +3802,12 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -3893,8 +3893,8 @@ code = '''
     memset(buffer_, 0xcc, BLOCK_SIZE);
     for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) {
         if (!(seen[block / 8] & (1 << (block % 8)))) {
-            cfg->erase(cfg, block) => 0;
-            cfg->prog(cfg, block, 0, buffer_, BLOCK_SIZE) => 0;
+            CFG->erase(CFG, block) => 0;
+            CFG->prog(CFG, block, 0, buffer_, BLOCK_SIZE) => 0;
         }
     }
     free(seen);
@@ -3923,12 +3923,12 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
     // create free lookahead
-    memset(lfs.lookahead.buffer, 0, lfs.cfg->lookahead_size);
+    memset(lfs.lookahead.buffer, 0, CFG->lookahead_size);
     lfs.lookahead.start = 0;
-    lfs.lookahead.size = lfs_min(8*lfs.cfg->lookahead_size,
-            lfs.cfg->block_count);
+    lfs.lookahead.size = lfs_min(8*CFG->lookahead_size,
+            CFG->block_count);
     lfs.lookahead.next = 0;
     lfs_alloc_ack(&lfs);
 
@@ -4041,8 +4041,8 @@ code = '''
     memset(buffer_, 0xcc, BLOCK_SIZE);
     for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) {
         if (!(seen[block / 8] & (1 << (block % 8)))) {
-            cfg->erase(cfg, block) => 0;
-            cfg->prog(cfg, block, 0, buffer_, BLOCK_SIZE) => 0;
+            CFG->erase(CFG, block) => 0;
+            CFG->prog(CFG, block, 0, buffer_, BLOCK_SIZE) => 0;
         }
     }
     free(seen);
diff --git a/tests/test_dirs.toml b/tests/test_dirs.toml
index fa6757a0..417083bb 100644
--- a/tests/test_dirs.toml
+++ b/tests/test_dirs.toml
@@ -9,10 +9,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make a directory
@@ -22,7 +22,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -56,8 +56,8 @@ code = '''
 defines.REMOUNT = [false, true]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // make a directory
     lfsr_mkdir(&lfs, "ardvark") => 0;
@@ -72,7 +72,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -103,8 +103,8 @@ code = '''
 defines.REMOUNT = [false, true]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // make a directory
     lfsr_mkdir(&lfs, "ardvark") => 0;
@@ -118,7 +118,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -152,10 +152,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make a directory
@@ -168,7 +168,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -203,10 +203,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // try to make root, which doesn't make sense
@@ -224,7 +224,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -259,10 +259,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make a directory
@@ -278,7 +278,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -312,10 +312,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make some directories
@@ -329,7 +329,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -375,10 +375,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make some directories
@@ -392,7 +392,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -461,10 +461,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make this many directories
@@ -477,7 +477,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -524,10 +524,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make this many directories
@@ -540,7 +540,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -587,10 +587,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make this many directories
@@ -609,7 +609,7 @@ code = '''
             // remount?
             if (REMOUNT) {
                 lfsr_unmount(&lfs) => 0;
-                lfsr_mount(&lfs, cfg) => 0;
+                lfsr_mount(&lfs, CFG) => 0;
                 // grm should be zero here
                 assert(lfs.pgrm[0] == 0);
             }
@@ -688,10 +688,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make this many directories
@@ -716,7 +716,7 @@ code = '''
                 // remount?
                 if (REMOUNT) {
                     lfsr_unmount(&lfs) => 0;
-                    lfsr_mount(&lfs, cfg) => 0;
+                    lfsr_mount(&lfs, CFG) => 0;
                     // grm should be zero here
                     assert(lfs.pgrm[0] == 0);
                 }
@@ -827,10 +827,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // create this many directory in a sort of linked-list by nesting
@@ -844,7 +844,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -899,10 +899,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     if (PARENT) {
@@ -946,7 +946,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -995,10 +995,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     assert(lfs_crc32c(0, "a_SNmwMTHH", 10) == 0x12345678);
@@ -1025,7 +1025,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1090,10 +1090,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000);
@@ -1120,7 +1120,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1187,10 +1187,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     assert(lfs_crc32c(0, "a_iomlVKPH", 10) == 0xffffffff);
@@ -1217,7 +1217,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1284,10 +1284,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     assert(lfs_crc32c(0, "a_IOtUptRH", 10) == 0x0000007f);
@@ -1314,7 +1314,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1381,10 +1381,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make a directory
@@ -1394,7 +1394,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1426,7 +1426,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1455,10 +1455,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make a directory
@@ -1477,7 +1477,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1512,10 +1512,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make a directory
@@ -1532,7 +1532,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1583,10 +1583,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // try to remove root, which doesn't really make sense
@@ -1605,7 +1605,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1639,10 +1639,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make some directories
@@ -1656,7 +1656,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1699,7 +1699,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1735,7 +1735,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1766,7 +1766,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1795,10 +1795,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make some directories
@@ -1812,7 +1812,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1875,7 +1875,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1931,7 +1931,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -1972,7 +1972,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -2008,10 +2008,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make this many directories
@@ -2025,7 +2025,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -2068,7 +2068,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -2123,10 +2123,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make this many directories
@@ -2140,7 +2140,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -2183,7 +2183,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -2238,10 +2238,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make this many directories
@@ -2262,7 +2262,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -2339,7 +2339,7 @@ code = '''
             // remount?
             if (REMOUNT) {
                 lfsr_unmount(&lfs) => 0;
-                lfsr_mount(&lfs, cfg) => 0;
+                lfsr_mount(&lfs, CFG) => 0;
                 // grm should be zero here
                 assert(lfs.pgrm[0] == 0);
             }
@@ -2354,7 +2354,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -2442,10 +2442,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make this many directories
@@ -2473,7 +2473,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -2582,7 +2582,7 @@ code = '''
                 // remount?
                 if (REMOUNT) {
                     lfsr_unmount(&lfs) => 0;
-                    lfsr_mount(&lfs, cfg) => 0;
+                    lfsr_mount(&lfs, CFG) => 0;
                     // grm should be zero here
                     assert(lfs.pgrm[0] == 0);
                 }
@@ -2597,7 +2597,7 @@ code = '''
             // remount?
             if (REMOUNT) {
                 lfsr_unmount(&lfs) => 0;
-                lfsr_mount(&lfs, cfg) => 0;
+                lfsr_mount(&lfs, CFG) => 0;
                 // grm should be zero here
                 assert(lfs.pgrm[0] == 0);
             }
@@ -2612,7 +2612,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -2740,10 +2740,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // create this many directory in a sort of linked-list by nesting
@@ -2758,7 +2758,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -2806,7 +2806,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -2861,10 +2861,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     if (PARENT) {
@@ -2926,7 +2926,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -2976,10 +2976,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make a directory
@@ -2995,7 +2995,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3027,7 +3027,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3062,10 +3062,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make directories
@@ -3077,7 +3077,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3112,7 +3112,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3147,10 +3147,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make directories
@@ -3160,7 +3160,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3192,7 +3192,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3226,10 +3226,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make directories
@@ -3251,7 +3251,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3286,10 +3286,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make directories
@@ -3307,7 +3307,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3364,10 +3364,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // try to rename root, which doesn't really make sense
@@ -3383,7 +3383,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3417,10 +3417,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make some directories
@@ -3444,7 +3444,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3487,7 +3487,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3528,7 +3528,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3569,7 +3569,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3613,10 +3613,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // make some directories
@@ -3646,7 +3646,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3709,7 +3709,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3770,7 +3770,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3831,7 +3831,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -3899,10 +3899,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // check if we have already started renaming, in case of powerloss
@@ -3920,7 +3920,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -3967,7 +3967,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4014,10 +4014,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // check if we have already started renaming, in case of powerloss
@@ -4035,7 +4035,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4082,7 +4082,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4129,10 +4129,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // check if we have already started renaming, in case of powerloss
@@ -4157,7 +4157,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4235,7 +4235,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4254,7 +4254,7 @@ code = '''
             // remount?
             if (REMOUNT) {
                 lfsr_unmount(&lfs) => 0;
-                lfsr_mount(&lfs, cfg) => 0;
+                lfsr_mount(&lfs, CFG) => 0;
                 // grm should be zero here
                 assert(lfs.pgrm[0] == 0);
             }
@@ -4334,10 +4334,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // check if we have already started renaming, in case of powerloss
@@ -4369,7 +4369,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4478,7 +4478,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4497,7 +4497,7 @@ code = '''
             // remount?
             if (REMOUNT) {
                 lfsr_unmount(&lfs) => 0;
-                lfsr_mount(&lfs, cfg) => 0;
+                lfsr_mount(&lfs, CFG) => 0;
                 // grm should be zero here
                 assert(lfs.pgrm[0] == 0);
             }
@@ -4518,7 +4518,7 @@ code = '''
                 // remount?
                 if (REMOUNT) {
                     lfsr_unmount(&lfs) => 0;
-                    lfsr_mount(&lfs, cfg) => 0;
+                    lfsr_mount(&lfs, CFG) => 0;
                     // grm should be zero here
                     assert(lfs.pgrm[0] == 0);
                 }
@@ -4636,10 +4636,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     // check if we have already started renaming, in case of powerloss
@@ -4658,7 +4658,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4714,7 +4714,7 @@ code = '''
         // remount?
         if (REMOUNT) {
             lfsr_unmount(&lfs) => 0;
-            lfsr_mount(&lfs, cfg) => 0;
+            lfsr_mount(&lfs, CFG) => 0;
             // grm should be zero here
             assert(lfs.pgrm[0] == 0);
         }
@@ -4773,10 +4773,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     if (PARENT) {
@@ -4861,7 +4861,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -4914,10 +4914,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     if (PARENT) {
@@ -5016,7 +5016,7 @@ code = '''
     // remount?
     if (REMOUNT) {
         lfsr_unmount(&lfs) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
         // grm should be zero here
         assert(lfs.pgrm[0] == 0);
     }
@@ -5065,8 +5065,8 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.PARENT = [false, true]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5116,8 +5116,8 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.PARENT = [false, true]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5187,8 +5187,8 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 defines.PARENT = [false, true]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5262,8 +5262,8 @@ defines.NEIGHBORS = [0x0, 0x1, 0x2, 0x3]
 if = 'PARENT || NEIGHBORS == 0'
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5357,8 +5357,8 @@ defines.SEEK = [0, 1, 2]
 if = 'PARENT || NEIGHBORS == 0'
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5452,8 +5452,8 @@ defines.SEEK = [0, 1, 2]
 if = 'PARENT || NEIGHBORS == 0'
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5556,8 +5556,8 @@ defines.SEEK = [0, 1, 2]
 if = 'PARENT || NEIGHBORS == 0'
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5673,8 +5673,8 @@ if = [
 ]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5778,8 +5778,8 @@ if = [
 ]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -5890,8 +5890,8 @@ if = [
 ]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     if (PARENT) {
         lfsr_mkdir(&lfs, "pricklypear") => 0;
@@ -6006,8 +6006,8 @@ defines.NEIGHBORS = [0x0, 0x1, 0x2, 0x3]
 defines.SEEK = [0, 1, 2]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     lfsr_mkdir(&lfs, "pricklypear") => 0;
 
@@ -6099,10 +6099,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     if (PARENT) {
@@ -6225,10 +6225,10 @@ reentrant = true
 code = '''
     // format once per test
     lfs_t lfs;
-    int err = lfsr_mount(&lfs, cfg);
+    int err = lfsr_mount(&lfs, CFG);
     if (err) {
-        lfsr_format(&lfs, cfg) => 0;
-        lfsr_mount(&lfs, cfg) => 0;
+        lfsr_format(&lfs, CFG) => 0;
+        lfsr_mount(&lfs, CFG) => 0;
     }
 
     if (PARENT) {
diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml
index 73c9e324..d25c430f 100644
--- a/tests/test_mtree.toml
+++ b/tests/test_mtree.toml
@@ -9,8 +9,8 @@ defines.LOOKAHEAD_SIZE = 'BLOCK_COUNT / 8'
 [cases.test_mtree_mroot]
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfsr_unmount(&lfs) => 0;
 '''
 
@@ -21,8 +21,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     for (lfs_size_t i = 0; i < N; i++) {
@@ -41,7 +41,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     for (lfs_size_t i = 0; i < N; i++) {
         uint8_t buffer[1];
@@ -60,8 +60,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     for (lfs_size_t i = 0; i < N; i++) {
@@ -83,7 +83,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     for (lfs_size_t i = 0; i < N; i++) {
         uint8_t buffer[1];
@@ -102,8 +102,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     for (lfs_size_t i = 0; i < N; i++) {
@@ -125,7 +125,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     lfsr_mdir_get(&lfs, &lfs.mroot,
             -1, LFSR_TAG_UATTR(1), buffer, 4) => 1;
@@ -145,8 +145,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -190,7 +190,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1);
@@ -220,8 +220,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -264,7 +264,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2);
@@ -294,8 +294,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -359,7 +359,7 @@ code = '''
     lfsr_unmount(&lfs) => 0;
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was split correctly
     assert(lfsr_mtree_weight(&lfs) == 2);
@@ -396,8 +396,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -411,8 +411,8 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.m.rbyd.off = cfg->block_size;
-            lfs.mroot.m.rbyd.off = cfg->block_size;
+            mdir.m.rbyd.off = CFG->block_size;
+            lfs.mroot.m.rbyd.off = CFG->block_size;
         }
 
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -449,7 +449,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // try looking up each entry
     i = 0;
@@ -483,8 +483,8 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -507,8 +507,8 @@ code = '''
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.m.rbyd.off = cfg->block_size;
-            lfs.mroot.m.rbyd.off = cfg->block_size;
+            mdir.m.rbyd.off = CFG->block_size;
+            lfs.mroot.m.rbyd.off = CFG->block_size;
         }
 
         // add to rbyd, potentially splitting the mdir
@@ -551,7 +551,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // try looking up each entry
     count_ = 0;
@@ -590,8 +590,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -638,7 +638,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0);
@@ -660,8 +660,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -711,7 +711,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0);
@@ -733,8 +733,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -771,7 +771,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0);
@@ -793,8 +793,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -836,7 +836,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1);
@@ -861,8 +861,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -904,7 +904,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1);
@@ -929,8 +929,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -963,7 +963,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0);
@@ -980,8 +980,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1045,7 +1045,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1);
@@ -1075,8 +1075,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1140,7 +1140,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 1);
@@ -1170,8 +1170,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1227,7 +1227,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0);
@@ -1252,8 +1252,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1287,8 +1287,8 @@ code = '''
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.m.rbyd.off = cfg->block_size;
-            lfs.mroot.m.rbyd.off = cfg->block_size;
+            mdir.m.rbyd.off = CFG->block_size;
+            lfs.mroot.m.rbyd.off = CFG->block_size;
         }
 
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -1318,7 +1318,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // try looking up each entry
     i = N - REMAINING;
@@ -1351,8 +1351,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1406,8 +1406,8 @@ code = '''
 
             // force a compaction?
             if (FORCE_COMPACTION) {
-                mdir.m.rbyd.off = cfg->block_size;
-                lfs.mroot.m.rbyd.off = cfg->block_size;
+                mdir.m.rbyd.off = CFG->block_size;
+                lfs.mroot.m.rbyd.off = CFG->block_size;
             }
 
             lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -1422,7 +1422,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     assert(lfsr_mtree_weight(&lfs) == 0);
     assert(lfs.mroot.m.rbyd.weight == 0);
@@ -1439,8 +1439,8 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1467,8 +1467,8 @@ code = '''
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.m.rbyd.off = cfg->block_size;
-            lfs.mroot.m.rbyd.off = cfg->block_size;
+            mdir.m.rbyd.off = CFG->block_size;
+            lfs.mroot.m.rbyd.off = CFG->block_size;
         }
 
         // create
@@ -1526,7 +1526,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // try looking up each entry
     count_ = 0;
@@ -1571,8 +1571,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1632,7 +1632,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mtree has one mdir
     assert(lfsr_mtree_weight(&lfs) == 1);
@@ -1667,8 +1667,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1727,7 +1727,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2);
@@ -1762,8 +1762,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1822,7 +1822,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2);
@@ -1857,8 +1857,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1892,7 +1892,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -1917,8 +1917,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -1954,7 +1954,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -1976,8 +1976,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2022,7 +2022,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert we relocated
     assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0);
@@ -2044,8 +2044,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2113,7 +2113,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mtree has one mdir
     assert(lfsr_mtree_weight(&lfs) == 1);
@@ -2151,8 +2151,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2225,7 +2225,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was split correctly
     assert(lfsr_mtree_weight(&lfs) == 2);
@@ -2265,8 +2265,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2321,7 +2321,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was dropped
     assert(lfsr_mtree_weight(&lfs) == 0);
@@ -2348,8 +2348,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2402,7 +2402,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdir was unininlined correctly
     assert(lfsr_mtree_weight(&lfs) == 1);
@@ -2437,8 +2437,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2490,7 +2490,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // assert mdirs were unininlined and split
     assert(lfsr_mtree_weight(&lfs) == 2);
@@ -2527,8 +2527,8 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2555,8 +2555,8 @@ code = '''
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.m.rbyd.off = cfg->block_size;
-            lfs.mroot.m.rbyd.off = cfg->block_size;
+            mdir.m.rbyd.off = CFG->block_size;
+            lfs.mroot.m.rbyd.off = CFG->block_size;
         }
 
         // create
@@ -2627,7 +2627,7 @@ code = '''
 
 
     // check things stay sane after remount
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
 
     // try looking up each entry
     count_ = 0;
@@ -2667,8 +2667,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2722,8 +2722,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2768,8 +2768,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2816,8 +2816,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2900,8 +2900,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -2979,8 +2979,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3086,8 +3086,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3157,8 +3157,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3255,8 +3255,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3352,8 +3352,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3446,8 +3446,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3523,8 +3523,8 @@ code = '''
     memset(buffer_, 0xcc, BLOCK_SIZE);
     for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) {
         if (!(seen[block / 8] & (1 << (block % 8)))) {
-            cfg->erase(cfg, block) => 0;
-            cfg->prog(cfg, block, 0, buffer_, BLOCK_SIZE) => 0;
+            CFG->erase(CFG, block) => 0;
+            CFG->prog(CFG, block, 0, buffer_, BLOCK_SIZE) => 0;
         }
     }
     free(seen);
@@ -3549,8 +3549,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3648,8 +3648,8 @@ code = '''
     memset(buffer_, 0xcc, BLOCK_SIZE);
     for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) {
         if (!(seen[block / 8] & (1 << (block % 8)))) {
-            cfg->erase(cfg, block) => 0;
-            cfg->prog(cfg, block, 0, buffer_, BLOCK_SIZE) => 0;
+            CFG->erase(CFG, block) => 0;
+            CFG->prog(CFG, block, 0, buffer_, BLOCK_SIZE) => 0;
         }
     }
     free(seen);
@@ -3685,8 +3685,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3784,8 +3784,8 @@ code = '''
     memset(buffer_, 0xcc, BLOCK_SIZE);
     for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) {
         if (!(seen[block / 8] & (1 << (block % 8)))) {
-            cfg->erase(cfg, block) => 0;
-            cfg->prog(cfg, block, 0, buffer_, BLOCK_SIZE) => 0;
+            CFG->erase(CFG, block) => 0;
+            CFG->prog(CFG, block, 0, buffer_, BLOCK_SIZE) => 0;
         }
     }
     free(seen);
@@ -3823,8 +3823,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3912,8 +3912,8 @@ code = '''
     memset(buffer_, 0xcc, BLOCK_SIZE);
     for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) {
         if (!(seen[block / 8] & (1 << (block % 8)))) {
-            cfg->erase(cfg, block) => 0;
-            cfg->prog(cfg, block, 0, buffer_, BLOCK_SIZE) => 0;
+            CFG->erase(CFG, block) => 0;
+            CFG->prog(CFG, block, 0, buffer_, BLOCK_SIZE) => 0;
         }
     }
     free(seen);
@@ -3940,8 +3940,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -3955,8 +3955,8 @@ code = '''
     for (lfs_size_t i = 0; i < N; i++) {
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.m.rbyd.off = cfg->block_size;
-            lfs.mroot.m.rbyd.off = cfg->block_size;
+            mdir.m.rbyd.off = CFG->block_size;
+            lfs.mroot.m.rbyd.off = CFG->block_size;
         }
 
         lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS(
@@ -4047,8 +4047,8 @@ code = '''
     memset(buffer_, 0xcc, BLOCK_SIZE);
     for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) {
         if (!(seen[block / 8] & (1 << (block % 8)))) {
-            cfg->erase(cfg, block) => 0;
-            cfg->prog(cfg, block, 0, buffer_, BLOCK_SIZE) => 0;
+            CFG->erase(CFG, block) => 0;
+            CFG->prog(CFG, block, 0, buffer_, BLOCK_SIZE) => 0;
         }
     }
     free(seen);
@@ -4087,8 +4087,8 @@ code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
 
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
     // remove root dstart for now
     lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS(
@@ -4111,8 +4111,8 @@ code = '''
 
         // force a compaction?
         if (FORCE_COMPACTION) {
-            mdir.m.rbyd.off = cfg->block_size;
-            lfs.mroot.m.rbyd.off = cfg->block_size;
+            mdir.m.rbyd.off = CFG->block_size;
+            lfs.mroot.m.rbyd.off = CFG->block_size;
         }
 
         // add to rbyd, potentially splitting the mdir
@@ -4210,8 +4210,8 @@ code = '''
     memset(buffer_, 0xcc, BLOCK_SIZE);
     for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) {
         if (!(seen[block / 8] & (1 << (block % 8)))) {
-            cfg->erase(cfg, block) => 0;
-            cfg->prog(cfg, block, 0, buffer_, BLOCK_SIZE) => 0;
+            CFG->erase(CFG, block) => 0;
+            CFG->prog(CFG, block, 0, buffer_, BLOCK_SIZE) => 0;
         }
     }
     free(seen);
@@ -4252,8 +4252,8 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     uint8_t buffer[LFSR_MPTR_DSIZE];
@@ -4317,7 +4317,7 @@ code = '''
 defines.SIZE = 'BLOCK_SIZE / 4'
 code = '''
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
 
     // check our magic string
     //
@@ -4325,9 +4325,9 @@ code = '''
     // but we don't lose power in this test so we can assert the magic string
     // is present in both
     uint8_t magic[lfs_max(16, READ_SIZE)];
-    cfg->read(cfg, 0, 0, magic, lfs_max(16, READ_SIZE)) => 0;
+    CFG->read(CFG, 0, 0, magic, lfs_max(16, READ_SIZE)) => 0;
     assert(memcmp(&magic[8], "littlefs", 8) == 0);
-    cfg->read(cfg, 1, 0, magic, lfs_max(16, READ_SIZE)) => 0;
+    CFG->read(CFG, 1, 0, magic, lfs_max(16, READ_SIZE)) => 0;
     assert(memcmp(&magic[8], "littlefs", 8) == 0);
 '''
 
@@ -4340,8 +4340,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     // prepare mroot with an attr
@@ -4377,9 +4377,9 @@ code = '''
     // but we don't lose power in this test so we can assert the magic string
     // is present in both
     uint8_t magic[lfs_max(16, READ_SIZE)];
-    cfg->read(cfg, 0, 0, magic, lfs_max(16, READ_SIZE)) => 0;
+    CFG->read(CFG, 0, 0, magic, lfs_max(16, READ_SIZE)) => 0;
     assert(memcmp(&magic[8], "littlefs", 8) == 0);
-    cfg->read(cfg, 1, 0, magic, lfs_max(16, READ_SIZE)) => 0;
+    CFG->read(CFG, 1, 0, magic, lfs_max(16, READ_SIZE)) => 0;
     assert(memcmp(&magic[8], "littlefs", 8) == 0);
 '''
 
@@ -4395,8 +4395,8 @@ in = 'lfs.c'
 code = '''
     const char *alphas = "abcdefghijklmnopqrstuvwxyz";
     lfs_t lfs;
-    lfsr_format(&lfs, cfg) => 0;
-    lfsr_mount(&lfs, cfg) => 0;
+    lfsr_format(&lfs, CFG) => 0;
+    lfsr_mount(&lfs, CFG) => 0;
     lfs_alloc_ack(&lfs);
 
     // prepare mroot with an attr
@@ -4434,9 +4434,9 @@ code = '''
     // but we don't lose power in this test so we can assert the magic string
     // is present in both
     uint8_t magic[lfs_max(16, READ_SIZE)];
-    cfg->read(cfg, 0, 0, magic, lfs_max(16, READ_SIZE)) => 0;
+    CFG->read(CFG, 0, 0, magic, lfs_max(16, READ_SIZE)) => 0;
     assert(memcmp(&magic[8], "littlefs", 8) == 0);
-    cfg->read(cfg, 1, 0, magic, lfs_max(16, READ_SIZE)) => 0;
+    CFG->read(CFG, 1, 0, magic, lfs_max(16, READ_SIZE)) => 0;
     assert(memcmp(&magic[8], "littlefs", 8) == 0);
 '''
 
diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml
index c4235c80..72b28b90 100644
--- a/tests/test_rbyd.toml
+++ b/tests/test_rbyd.toml
@@ -17,7 +17,7 @@ defines.BLOCK_SIZE = 32768
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -48,7 +48,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -80,7 +80,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -113,7 +113,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -223,7 +223,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -335,7 +335,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -414,7 +414,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -495,7 +495,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -558,7 +558,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -623,7 +623,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -702,7 +702,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -845,7 +845,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -1016,7 +1016,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -1187,7 +1187,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -1366,7 +1366,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -1573,7 +1573,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -1739,7 +1739,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -1926,7 +1926,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2017,7 +2017,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2098,7 +2098,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2187,7 +2187,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2282,7 +2282,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2354,7 +2354,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2425,7 +2425,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2535,7 +2535,7 @@ in = 'lfs.c'
 defines.ORDER = [0, 1, 2]
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2597,7 +2597,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2709,7 +2709,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2776,7 +2776,7 @@ code = '''
                     LFSR_ATTR(-1, RMUATTR(j+1), 0, NULL, 0)))
                     => 0;
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
                 int err = lfsr_rbyd_lookupnext(&lfs, &rbyd,
                         -1, LFSR_TAG_UATTR(k+1),
@@ -2805,7 +2805,7 @@ code = '''
                         "\xaa\xaa\xaa\xaa\xaa\xaa", 6)))
                     => 0;
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_lookupnext(&lfs, &rbyd,
                         -1, LFSR_TAG_UATTR(k+1),
@@ -2859,7 +2859,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -2922,7 +2922,7 @@ code = '''
                     LFSR_ATTR(-1, RMUATTR(j+1), 0, NULL, 0))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
 
             tag_ = 0;
             id_ = -1;
@@ -2953,7 +2953,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -3102,7 +3102,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -3337,7 +3337,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -3425,7 +3425,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -3548,7 +3548,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -3656,7 +3656,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -3803,7 +3803,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -3964,7 +3964,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -4066,7 +4066,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -4159,7 +4159,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -4265,7 +4265,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -4377,7 +4377,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -4469,7 +4469,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -4556,7 +4556,7 @@ in = 'lfs.c'
 defines.ORDER = [0, 1, 2]
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -4624,7 +4624,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -4858,7 +4858,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -5119,7 +5119,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -5233,7 +5233,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -5337,7 +5337,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -5503,7 +5503,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -5680,7 +5680,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -5790,7 +5790,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -5899,7 +5899,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -6027,7 +6027,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -6115,7 +6115,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(j/M, RMUATTR((j%M)+1), 0, NULL, 0))) => 0;
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
@@ -6155,7 +6155,7 @@ code = '''
             lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS(
                     LFSR_ATTR(j/M, UATTR((j%M)+1), 0, names[(j/M)%6], 3))) => 0;
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
                 assert(memcmp(buffer, names[k % 6], 4) == 0);
@@ -6221,7 +6221,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -6345,7 +6345,7 @@ defines.ORDER = [0, 1, 2]
 defines.M = 'range(1, 4)'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -6436,7 +6436,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -6575,7 +6575,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -6731,7 +6731,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -6857,7 +6857,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -7103,7 +7103,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -7185,7 +7185,7 @@ code = '''
                     LFSR_ATTR(j, UNR, -1, NULL, 0))) => 0;
             assert(rbyd.weight == N-1);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
             for (unsigned k = 0; k < N-1; k++) {
                 lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
@@ -7204,7 +7204,7 @@ code = '''
                     LFSR_ATTR(j, REG, +1, names[j % 6], 6))) => 0;
             assert(rbyd.weight == N);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -7257,7 +7257,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -7345,7 +7345,7 @@ code = '''
                     LFSR_ATTR(j, UNR, -1, NULL, 0))) => 0;
             assert(rbyd.weight == N-1);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
             for (unsigned k = 0; k < N-1; k++) {
                 lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4;
@@ -7381,7 +7381,7 @@ code = '''
             }
             assert(rbyd.weight == N);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -7447,7 +7447,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -7529,7 +7529,7 @@ code = '''
             assert(rbyd.weight == N-1);
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
 
             tag_ = 0;
@@ -7571,7 +7571,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -7659,7 +7659,7 @@ code = '''
             assert(rbyd.weight == N-1);
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N-1);
 
             tag_ = 0;
@@ -7709,7 +7709,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -7823,7 +7823,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -7956,7 +7956,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -8098,7 +8098,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -8255,7 +8255,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -8361,7 +8361,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -8598,7 +8598,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -8707,7 +8707,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -8793,7 +8793,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -8878,7 +8878,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -9550,7 +9550,7 @@ code = '''
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -9806,7 +9806,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -9917,7 +9917,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -10038,7 +10038,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -10119,7 +10119,7 @@ code = '''
                     LFSR_ATTR(j*W+W-1, UNR, +D, NULL, 0))) => 0;
             assert(rbyd.weight == N*W+D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W+D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10164,7 +10164,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -10246,7 +10246,7 @@ code = '''
                         names[j % 6], 6))) => 0;
             assert(rbyd.weight == N*W+D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W+D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10299,7 +10299,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -10382,7 +10382,7 @@ code = '''
                         names[j % 6], 6))) => 0;
             assert(rbyd.weight == N*W+D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W+D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10447,7 +10447,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -10528,7 +10528,7 @@ code = '''
                     LFSR_ATTR(j*W+W-1, GROW, -D, NULL, 0))) => 0;
             assert(rbyd.weight == N*W-D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W-D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10573,7 +10573,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -10655,7 +10655,7 @@ code = '''
                         names[j % 6], 6))) => 0;
             assert(rbyd.weight == N*W-D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W-D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10708,7 +10708,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -10791,7 +10791,7 @@ code = '''
                         names[j % 6], 6))) => 0;
             assert(rbyd.weight == N*W-D);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W-D);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -10855,7 +10855,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -10936,7 +10936,7 @@ code = '''
                     LFSR_ATTR(j*W+W-1, UNR, -W, NULL, 0))) => 0;
             assert(rbyd.weight == (N-1)*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == (N-1)*W);
             for (unsigned k = 0; k < N-1; k++) {
                 if (k >= j) {
@@ -10968,7 +10968,7 @@ code = '''
                     LFSR_ATTR(j*W, REG, +W, names[j % 6], 6))) => 0;
             assert(rbyd.weight == N*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W);
             for (unsigned k = 0; k < N; k++) {
                 if (k == j) {
@@ -11008,7 +11008,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -11090,7 +11090,7 @@ code = '''
                     LFSR_ATTR(j*W+W-1, UATTR(1), 0, names[j % 6], 2))) => 0;
             assert(rbyd.weight == N*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W);
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -11120,7 +11120,7 @@ code = '''
                     LFSR_ATTR(j*W+W-1, RMUATTR(1), 0, NULL, 0))) => 0;
             assert(rbyd.weight == N*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W);
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -11145,7 +11145,7 @@ code = '''
                     LFSR_ATTR(j*W+W-1, UATTR(1), 0, names[j % 6], 2))) => 0;
             assert(rbyd.weight == N*W);
 
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             assert(rbyd.weight == N*W);
             for (unsigned k = 0; k < N; k++) {
                 lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG,
@@ -11184,7 +11184,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -11335,7 +11335,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -11530,7 +11530,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -11617,7 +11617,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -11697,7 +11697,7 @@ code = '''
                     LFSR_ATTR(j, RMWIDEUATTR, 0, NULL, 0))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t id_ = -1;
             lfs_size_t weight_;
@@ -11754,7 +11754,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -11835,7 +11835,7 @@ code = '''
                         names[j % 6], 3))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t id_ = -1;
             lfs_size_t weight_;
@@ -11893,7 +11893,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -11981,7 +11981,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -12062,7 +12062,7 @@ code = '''
                     LFSR_ATTR(j, RMWIDEUATTR, 0, NULL, 0))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t id_ = -1;
             lfs_size_t weight_;
@@ -12126,7 +12126,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -12208,7 +12208,7 @@ code = '''
                         names[j % 6], 3))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t id_ = -1;
             lfs_size_t weight_;
@@ -12273,7 +12273,7 @@ defines.PERMUTATION = -1
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -12359,7 +12359,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -12438,7 +12438,7 @@ code = '''
                     LFSR_ATTR(j, RMWIDEUATTR, 0, NULL, 0))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t id_ = -1;
             lfs_size_t weight_;
@@ -12498,7 +12498,7 @@ if = 'PROG_SIZE < 512'
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
+    lfs_init(&lfs, CFG) => 0;
 
     lfsr_rbyd_t init_rbyd = {
         .block = 0,
@@ -12578,7 +12578,7 @@ code = '''
                         names[j % 6], 6))) => 0;
 
             // try traversing over the tags
-            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size) => 0;
+            lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0;
             lfsr_tag_t tag_ = 0;
             lfs_ssize_t id_ = -1;
             lfs_size_t weight_;