diff --git a/lfs.c b/lfs.c
index 68f7a9d3..77b61b6f 100644
--- a/lfs.c
+++ b/lfs.c
@@ -7461,10 +7461,8 @@ typedef struct lfsr_traversal {
     // we really don't want to pay the RAM cost for a full file,
     // so only store the relevant bits, is this a hack? yes
     struct {
-        lfsr_opened_t *next;
-        uint8_t type;
-        uint16_t flags;
-        lfsr_mdir_t mdir;
+        lfsr_opened_t m;
+        const struct lfs_file_config *cfg;
         lfsr_bshrub_t bshrub;
     } file;
     lfsr_btraversal_t bt;
@@ -7521,7 +7519,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
         //
         case LFSR_TRAVERSAL_MROOTANCHOR:;
             // fetch the first mroot 0x{0,1}
-            int err = lfsr_mdir_fetch(lfs, &t->file.mdir,
+            int err = lfsr_mdir_fetch(lfs, &t->file.m.mdir,
                     -1, &LFSR_MPTR_MROOTANCHOR());
             if (err) {
                 return err;
@@ -7532,7 +7530,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
 
             if (tinfo_) {
                 tinfo_->tag = LFSR_TAG_MDIR;
-                tinfo_->u.mdir = t->file.mdir;
+                tinfo_->u.mdir = t->file.m.mdir;
             }
             return 0;
 
@@ -7541,14 +7539,14 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
             // lookup mroot, if we find one this is a fake mroot
             lfsr_tag_t tag;
             lfsr_data_t data;
-            err = lfsr_mdir_sublookup(lfs, &t->file.mdir,
+            err = lfsr_mdir_sublookup(lfs, &t->file.m.mdir,
                     LFSR_TAG_STRUCT,
                     &tag, &data);
             if (err) {
                 // if we have no mtree/mdir (inlined mdir), we need to traverse
                 // any files in our mroot next
                 if (err == LFS_ERR_NOENT) {
-                    t->file.mdir.mid = 0;
+                    t->file.m.mdir.mid = 0;
                     t->state = LFSR_TRAVERSAL_MDIR;
                     continue;
                 }
@@ -7586,14 +7584,14 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
                 t->u.mtortoise.step += 1;
 
                 // fetch this mroot
-                err = lfsr_mdir_fetch(lfs, &t->file.mdir, -1, &mptr);
+                err = lfsr_mdir_fetch(lfs, &t->file.m.mdir, -1, &mptr);
                 if (err) {
                     return err;
                 }
 
                 if (tinfo_) {
                     tinfo_->tag = LFSR_TAG_MDIR;
-                    tinfo_->u.mdir = t->file.mdir;
+                    tinfo_->u.mdir = t->file.m.mdir;
                 }
                 return 0;
 
@@ -7606,7 +7604,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
                     return err;
                 }
 
-                err = lfsr_mdir_fetch(lfs, &t->file.mdir, 0, &mptr);
+                err = lfsr_mdir_fetch(lfs, &t->file.m.mdir, 0, &mptr);
                 if (err) {
                     return err;
                 }
@@ -7616,7 +7614,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
 
                 if (tinfo_) {
                     tinfo_->tag = LFSR_TAG_MDIR;
-                    tinfo_->u.mdir = t->file.mdir;
+                    tinfo_->u.mdir = t->file.m.mdir;
                 }
                 return 0;
 
@@ -7719,7 +7717,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
                     return err;
                 }
 
-                err = lfsr_mdir_fetch(lfs, &t->file.mdir,
+                err = lfsr_mdir_fetch(lfs, &t->file.m.mdir,
                         LFSR_MID(lfs, bid, 0),
                         &mptr);
                 if (err) {
@@ -7731,7 +7729,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
 
                 if (tinfo_) {
                     tinfo_->tag = LFSR_TAG_MDIR;
-                    tinfo_->u.mdir = t->file.mdir;
+                    tinfo_->u.mdir = t->file.m.mdir;
                 }
                 return 0;
 
@@ -7745,14 +7743,14 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
             // not traversing all blocks? have we exceeded our mdir's weight?
             // return to mtree traversal
             if (!lfsr_traversal_isall(t)
-                    || lfsr_mid_rid(lfs, t->file.mdir.mid)
-                        >= (lfsr_srid_t)t->file.mdir.rbyd.weight) {
+                    || lfsr_mid_rid(lfs, t->file.m.mdir.mid)
+                        >= (lfsr_srid_t)t->file.m.mdir.rbyd.weight) {
                 t->state = LFSR_TRAVERSAL_MTREE;
                 continue;
             }
 
             // do we have a block/btree?
-            err = lfsr_mdir_lookupnext(lfs, &t->file.mdir, LFSR_TAG_DATA,
+            err = lfsr_mdir_lookupnext(lfs, &t->file.m.mdir, LFSR_TAG_DATA,
                     &tag, &data);
             if (err && err != LFS_ERR_NOENT) {
                 return err;
@@ -7767,7 +7765,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
 
             // found a bshrub (inlined btree)?
             } else if (err != LFS_ERR_NOENT && tag == LFSR_TAG_BSHRUB) {
-                err = lfsr_data_readshrub(lfs, &data, &t->file.mdir,
+                err = lfsr_data_readshrub(lfs, &data, &t->file.m.mdir,
                         &t->file.bshrub.u.bshrub);
                 if (err) {
                     return err;
@@ -7783,7 +7781,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
 
             // no? continue to next file
             } else {
-                t->file.mdir.mid += 1;
+                t->file.m.mdir.mid += 1;
                 continue;
             }
 
@@ -7808,7 +7806,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
 
             // start traversing the file
             const lfsr_file_t *file = (const lfsr_file_t*)t->u.o;
-            t->file.mdir = file->m.mdir;
+            t->file.m.mdir = file->m.mdir;
             t->file.bshrub = file->bshrub;
             t->bt = LFSR_BTRAVERSAL();
             t->state = LFSR_TRAVERSAL_OPENEDBTREE;
@@ -7826,7 +7824,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t,
                 if (err == LFS_ERR_NOENT) {
                     // end of btree? go to next file
                     if (t->state == LFSR_TRAVERSAL_MDIRBTREE) {
-                        t->file.mdir.mid += 1;
+                        t->file.m.mdir.mid += 1;
                         t->state = LFSR_TRAVERSAL_MDIR;
                         continue;
                     } else if (t->state == LFSR_TRAVERSAL_OPENEDBTREE) {
@@ -15304,29 +15302,18 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
         lfs->file_limit = LFS_FILE_MAX;
     }
 
-    LFS_ASSERT(lfs->cfg->uattr_limit <= LFS_UATTR_MAX);
-    lfs->uattr_limit = lfs->cfg->uattr_limit;
-    if (!lfs->uattr_limit) {
-        lfs->uattr_limit = LFS_UATTR_MAX;
-    }
-
-    LFS_ASSERT(lfs->cfg->sattr_limit <= LFS_SATTR_MAX);
-    lfs->sattr_limit = lfs->cfg->sattr_limit;
-    if (!lfs->sattr_limit) {
-        lfs->sattr_limit = LFS_SATTR_MAX;
-    }
-
     // setup default state
+    lfs->seed = 0;
+
 //    lfs->root[0] = LFS_BLOCK_NULL;
 //    lfs->root[1] = LFS_BLOCK_NULL;
-    lfs->mlist = NULL;
-    lfs->seed = 0;
-    lfs->gdisk = (lfs_gstate_t){0};
-    lfs->gstate = (lfs_gstate_t){0};
-    lfs->gdelta = (lfs_gstate_t){0};
-#ifdef LFS_MIGRATE
-    lfs->lfs1 = NULL;
-#endif
+//    lfs->mlist = NULL;
+//    lfs->gdisk = (lfs_gstate_t){0};
+//    lfs->gstate = (lfs_gstate_t){0};
+//    lfs->gdelta = (lfs_gstate_t){0};
+//#ifdef LFS_MIGRATE
+//    lfs->lfs1 = NULL;
+//#endif
 
     // TODO maybe reorganize this function?
 
diff --git a/lfs.h b/lfs.h
index 28824cc9..02dcffdf 100644
--- a/lfs.h
+++ b/lfs.h
@@ -81,15 +81,15 @@ typedef int32_t  lfsr_sdid_t;
 //#ifndef LFS_ATTR_MAX
 //#define LFS_ATTR_MAX 1022
 //#endif
-
-// TODO document
-#ifndef LFS_UATTR_MAX
-#define LFS_UATTR_MAX 255
-#endif
-
-#ifndef LFS_SATTR_MAX
-#define LFS_SATTR_MAX 255
-#endif
+//
+//// TODO document
+//#ifndef LFS_UATTR_MAX
+//#define LFS_UATTR_MAX 255
+//#endif
+//
+//#ifndef LFS_SATTR_MAX
+//#define LFS_SATTR_MAX 255
+//#endif
 
 
 // Possible error codes, these are negative to allow
@@ -258,10 +258,6 @@ struct lfs_config {
     // in superblock and must be respected by other littlefs drivers.
     lfs_size_t file_limit;
 
-    // TODO document
-    lfs_size_t uattr_limit;
-    lfs_size_t sattr_limit;
-
 // TODO rm me
 //    // Optional upper limit on custom attributes in bytes. No downside for
 //    // larger attributes size but must be <= LFS_ATTR_MAX. Defaults to
@@ -320,19 +316,19 @@ struct lfs_info {
     char name[LFS_NAME_MAX+1];
 };
 
-// Custom attribute structure, used to describe custom attributes
-// committed atomically during file writes.
-struct lfs_attr {
-    // 8-bit type of attribute, provided by user and used to
-    // identify the attribute
-    uint8_t type;
-
-    // Pointer to buffer containing the attribute
-    void *buffer;
-
-    // Size of attribute in bytes, limited to LFS_ATTR_MAX
-    lfs_size_t size;
-};
+//// Custom attribute structure, used to describe custom attributes
+//// committed atomically during file writes.
+//struct lfs_attr {
+//    // 8-bit type of attribute, provided by user and used to
+//    // identify the attribute
+//    uint8_t type;
+//
+//    // Pointer to buffer containing the attribute
+//    void *buffer;
+//
+//    // Size of attribute in bytes, limited to LFS_ATTR_MAX
+//    lfs_size_t size;
+//};
 
 // Optional configuration provided during lfs_file_opencfg
 struct lfs_file_config {
@@ -345,31 +341,32 @@ struct lfs_file_config {
     // accesses. Defaults to file_buffer_size.
     lfs_size_t buffer_size;
 
-    // Optional list of custom attributes related to the file. If the file
-    // is opened with read access, these attributes will be read from disk
-    // during the open call. If the file is opened with write access, the
-    // attributes will be written to disk every file sync or close. This
-    // write occurs atomically with update to the file's contents.
-    //
-    // Custom attributes are uniquely identified by an 8-bit type and limited
-    // to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller
-    // than the buffer, it will be padded with zeros. If the stored attribute
-    // is larger, then it will be silently truncated. If the attribute is not
-    // found, it will be created implicitly.
-    struct lfs_attr *attrs;
-
-    // Number of custom attributes in the list
-    lfs_size_t attr_count;
+//    // Optional list of custom attributes related to the file. If the file
+//    // is opened with read access, these attributes will be read from disk
+//    // during the open call. If the file is opened with write access, the
+//    // attributes will be written to disk every file sync or close. This
+//    // write occurs atomically with update to the file's contents.
+//    //
+//    // Custom attributes are uniquely identified by an 8-bit type and limited
+//    // to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller
+//    // than the buffer, it will be padded with zeros. If the stored attribute
+//    // is larger, then it will be silently truncated. If the attribute is not
+//    // found, it will be created implicitly.
+//    struct lfs_attr *attrs;
+//
+//    // Number of custom attributes in the list
+//    lfs_size_t attr_count;
 };
 
 
 /// internal littlefs data structures ///
-typedef struct lfs_cache {
-    lfs_block_t block;
-    lfs_size_t off;
-    lfs_size_t size;
-    uint8_t *buffer;
-} lfs_cache_t;
+
+//typedef struct lfs_cache {
+//    lfs_block_t block;
+//    lfs_size_t off;
+//    lfs_size_t size;
+//    uint8_t *buffer;
+//} lfs_cache_t;
 
 // TODO do we get ram savings with a lfsr_rorbyd_t substruct? need to measure
 typedef struct lfsr_rbyd {
@@ -418,16 +415,16 @@ typedef struct lfsr_opened {
 } lfsr_opened_t;
 
 
-typedef struct lfs_mdir {
-    lfs_block_t pair[2];
-    uint32_t rev;
-    lfs_off_t off;
-    uint32_t etag;
-    uint16_t count;
-    bool erased;
-    bool split;
-    lfs_block_t tail[2];
-} lfs_mdir_t;
+//typedef struct lfs_mdir {
+//    lfs_block_t pair[2];
+//    uint32_t rev;
+//    lfs_off_t off;
+//    uint32_t etag;
+//    uint16_t count;
+//    bool erased;
+//    bool split;
+//    lfs_block_t tail[2];
+//} lfs_mdir_t;
 
 // either an on-disk or in-device data pointer
 typedef struct lfsr_data {
@@ -444,15 +441,16 @@ typedef struct lfsr_data {
 } lfsr_data_t;
 
 // littlefs directory type
-typedef struct lfs_dir {
-    struct lfs_dir *next;
-    uint16_t id;
-    uint8_t type;
-    lfs_mdir_t m;
 
-    lfs_off_t pos;
-    lfs_block_t head[2];
-} lfs_dir_t;
+//typedef struct lfs_dir {
+//    struct lfs_dir *next;
+//    uint16_t id;
+//    uint8_t type;
+//    lfs_mdir_t m;
+//
+//    lfs_off_t pos;
+//    lfs_block_t head[2];
+//} lfs_dir_t;
 
 typedef struct lfsr_dir {
     lfsr_opened_t p; // pos mdir
@@ -462,25 +460,26 @@ typedef struct lfsr_dir {
 } lfsr_dir_t;
 
 // littlefs file type
-typedef struct lfs_file {
-    struct lfs_file *next;
-    uint16_t id;
-    uint8_t type;
-    lfs_mdir_t m;
 
-    struct lfs_ctz {
-        lfs_block_t head;
-        lfs_size_t size;
-    } ctz;
-
-    uint32_t flags;
-    lfs_off_t pos;
-    lfs_block_t block;
-    lfs_off_t off;
-    lfs_cache_t cache;
-
-    const struct lfs_file_config *cfg;
-} lfs_file_t;
+//typedef struct lfs_file {
+//    struct lfs_file *next;
+//    uint16_t id;
+//    uint8_t type;
+//    lfs_mdir_t m;
+//
+//    struct lfs_ctz {
+//        lfs_block_t head;
+//        lfs_size_t size;
+//    } ctz;
+//
+//    uint32_t flags;
+//    lfs_off_t pos;
+//    lfs_block_t block;
+//    lfs_off_t off;
+//    lfs_cache_t cache;
+//
+//    const struct lfs_file_config *cfg;
+//} lfs_file_t;
 
 typedef lfsr_data_t lfsr_sprout_t;
 
@@ -512,6 +511,7 @@ typedef struct lfsr_bshrub {
 
 typedef struct lfsr_file {
     lfsr_opened_t m;
+    const struct lfs_file_config *cfg;
 
     // files contain both an active bshrub and staging bshrub, to allow
     // staging during mdir compacts
@@ -528,23 +528,21 @@ typedef struct lfsr_file {
 
     lfs_block_t eblock;
     lfs_size_t eoff;
-
-    const struct lfs_file_config *cfg;
 } lfsr_file_t;
 
-typedef struct lfs_superblock {
-    uint32_t version;
-    lfs_size_t block_size;
-    lfs_size_t block_count;
-    lfs_size_t name_max;
-    lfs_size_t file_max;
-    lfs_size_t attr_max;
-} lfs_superblock_t;
-
-typedef struct lfs_gstate {
-    uint32_t tag;
-    lfs_block_t pair[2];
-} lfs_gstate_t;
+//typedef struct lfs_superblock {
+//    uint32_t version;
+//    lfs_size_t block_size;
+//    lfs_size_t block_count;
+//    lfs_size_t name_max;
+//    lfs_size_t file_max;
+//    lfs_size_t attr_max;
+//} lfs_superblock_t;
+//
+//typedef struct lfs_gstate {
+//    uint32_t tag;
+//    lfs_block_t pair[2];
+//} lfs_gstate_t;
 
 typedef struct lfsr_mtree {
     union {
@@ -576,6 +574,24 @@ typedef struct lfsr_grm {
 
 // The littlefs filesystem type
 typedef struct lfs {
+    const struct lfs_config *cfg;
+    lfs_size_t name_limit;
+    lfs_off_t file_limit;
+
+    // TODO we should put this flag somewhere, should lfs_t have a general
+    // purpose flags field? this has been useful for lfsr_file_t
+    bool hasorphans;
+
+    uint8_t attr_estimate;
+    uint8_t mleaf_bits;
+
+    // linked-list of opened mdirs
+    lfsr_opened_t *opened;
+
+    lfsr_mdir_t mroot;
+    lfsr_mtree_t mtree;
+    uint32_t seed;
+
     struct {
         lfs_block_t block;
         lfs_size_t off;
@@ -590,19 +606,6 @@ typedef struct lfs {
     } pcache;
     uint32_t pcksum;
 
-    lfs_block_t root[2];
-    struct lfs_mlist {
-        struct lfs_mlist *next;
-        uint16_t id;
-        uint8_t type;
-        lfs_mdir_t m;
-    } *mlist;
-    uint32_t seed;
-
-    lfs_gstate_t gstate;
-    lfs_gstate_t gdisk;
-    lfs_gstate_t gdelta;
-
     struct lfs_lookahead {
         lfs_block_t start;
         lfs_block_t size;
@@ -611,33 +614,9 @@ typedef struct lfs {
         uint8_t *buffer;
     } lookahead;
 
-    const struct lfs_config *cfg;
-    lfs_size_t name_limit;
-    lfs_off_t file_limit;
-    lfs_size_t uattr_limit;
-    lfs_size_t sattr_limit;
-
-    // begin lfsr things
     lfsr_grm_t grm;
     uint8_t grm_g[LFSR_GRM_DSIZE];
     uint8_t grm_d[LFSR_GRM_DSIZE];
-
-    // TODO we should put this flag somewhere, should lfs_t have a general
-    // purpose flags field? this has been useful for lfsr_file_t
-    bool hasorphans;
-
-    uint8_t attr_estimate;
-    uint8_t mleaf_bits;
-
-    lfsr_mdir_t mroot;
-    lfsr_mtree_t mtree;
-
-    // linked-list of opened mdirs
-    lfsr_opened_t *opened;
-
-#ifdef LFS_MIGRATE
-    struct lfs1 *lfs1;
-#endif
 } lfs_t;
 
 
@@ -651,7 +630,7 @@ typedef struct lfs {
 // be zeroed for defaults and backwards compatibility.
 //
 // Returns a negative error code on failure.
-int lfs_format(lfs_t *lfs, const struct lfs_config *config);
+//int lfs_format(lfs_t *lfs, const struct lfs_config *config);
 int lfsr_format(lfs_t *lfs, const struct lfs_config *config);
 #endif
 
@@ -663,14 +642,14 @@ int lfsr_format(lfs_t *lfs, const struct lfs_config *config);
 // be zeroed for defaults and backwards compatibility.
 //
 // Returns a negative error code on failure.
-int lfs_mount(lfs_t *lfs, const struct lfs_config *config);
+//int lfs_mount(lfs_t *lfs, const struct lfs_config *config);
 int lfsr_mount(lfs_t *lfs, const struct lfs_config *config);
 
 // Unmounts a littlefs
 //
 // Does nothing besides releasing any allocated resources.
 // Returns a negative error code on failure.
-int lfs_unmount(lfs_t *lfs);
+//int lfs_unmount(lfs_t *lfs);
 int lfsr_unmount(lfs_t *lfs);
 
 /// General operations ///
@@ -680,7 +659,7 @@ int lfsr_unmount(lfs_t *lfs);
 //
 // If removing a directory, the directory must be empty.
 // Returns a negative error code on failure.
-int lfs_remove(lfs_t *lfs, const char *path);
+//int lfs_remove(lfs_t *lfs, const char *path);
 int lfsr_remove(lfs_t *lfs, const char *path);
 #endif
 
@@ -691,7 +670,7 @@ int lfsr_remove(lfs_t *lfs, const char *path);
 // If the destination is a directory, the directory must be empty.
 //
 // Returns a negative error code on failure.
-int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath);
+//int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath);
 int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path);
 #endif
 
@@ -699,7 +678,7 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path);
 //
 // Fills out the info structure, based on the specified file or directory.
 // Returns a negative error code on failure.
-int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info);
+//int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info);
 int lfsr_stat(lfs_t *lfs, const char *path, struct lfs_info *info);
 
 // Get a custom attribute
@@ -714,8 +693,8 @@ int lfsr_stat(lfs_t *lfs, const char *path, struct lfs_info *info);
 // Note, the returned size is the size of the attribute on disk, irrespective
 // of the size of the buffer. This can be used to dynamically allocate a buffer
 // or check for existence.
-lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path,
-        uint8_t type, void *buffer, lfs_size_t size);
+//lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path,
+//        uint8_t type, void *buffer, lfs_size_t size);
 
 #ifndef LFS_READONLY
 // Set custom attributes
@@ -725,8 +704,8 @@ lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path,
 // implicitly created.
 //
 // Returns a negative error code on failure.
-int lfs_setattr(lfs_t *lfs, const char *path,
-        uint8_t type, const void *buffer, lfs_size_t size);
+//int lfs_setattr(lfs_t *lfs, const char *path,
+//        uint8_t type, const void *buffer, lfs_size_t size);
 #endif
 
 #ifndef LFS_READONLY
@@ -735,7 +714,7 @@ int lfs_setattr(lfs_t *lfs, const char *path,
 // If an attribute is not found, nothing happens.
 //
 // Returns a negative error code on failure.
-int lfs_removeattr(lfs_t *lfs, const char *path, uint8_t type);
+//int lfs_removeattr(lfs_t *lfs, const char *path, uint8_t type);
 #endif
 
 
@@ -748,8 +727,8 @@ int lfs_removeattr(lfs_t *lfs, const char *path, uint8_t type);
 // are values from the enum lfs_open_flags that are bitwise-ored together.
 //
 // Returns a negative error code on failure.
-int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
-        const char *path, int flags);
+//int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
+//        const char *path, int flags);
 int lfsr_file_open(lfs_t *lfs, lfsr_file_t *file,
         const char *path, uint32_t flags);
 
@@ -767,9 +746,9 @@ int lfsr_file_open(lfs_t *lfs, lfsr_file_t *file,
 // the config struct must be zeroed for defaults and backwards compatibility.
 //
 // Returns a negative error code on failure.
-int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file,
-        const char *path, int flags,
-        const struct lfs_file_config *config);
+//int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file,
+//        const char *path, int flags,
+//        const struct lfs_file_config *config);
 int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file,
         const char *path, uint32_t flags,
         const struct lfs_file_config *config);
@@ -785,7 +764,7 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file,
 // return 0.
 //
 // Returns a negative error code on failure.
-int lfs_file_close(lfs_t *lfs, lfs_file_t *file);
+//int lfs_file_close(lfs_t *lfs, lfs_file_t *file);
 int lfsr_file_close(lfs_t *lfs, lfsr_file_t *file);
 
 // Synchronize a file on storage
@@ -796,7 +775,7 @@ int lfsr_file_close(lfs_t *lfs, lfsr_file_t *file);
 // now recieve file updates and syncs on close.
 //
 // Returns a negative error code on failure.
-int lfs_file_sync(lfs_t *lfs, lfs_file_t *file);
+//int lfs_file_sync(lfs_t *lfs, lfs_file_t *file);
 int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file);
 
 // Mark a file as desynchronized
@@ -827,8 +806,8 @@ int lfsr_file_flush(lfs_t *lfs, lfsr_file_t *file);
 //
 // Takes a buffer and size indicating where to store the read data.
 // Returns the number of bytes read, or a negative error code on failure.
-lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
-        void *buffer, lfs_size_t size);
+//lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
+//        void *buffer, lfs_size_t size);
 lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file,
         void *buffer, lfs_size_t size);
 
@@ -839,8 +818,8 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file,
 // actually be updated on the storage until either sync or close is called.
 //
 // Returns the number of bytes written, or a negative error code on failure.
-lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
-        const void *buffer, lfs_size_t size);
+//lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
+//        const void *buffer, lfs_size_t size);
 lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file,
         const void *buffer, lfs_size_t size);
 #endif
@@ -849,8 +828,8 @@ lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file,
 //
 // The change in position is determined by the offset and whence flag.
 // Returns the new position of the file, or a negative error code on failure.
-lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file,
-        lfs_soff_t off, int whence);
+//lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file,
+//        lfs_soff_t off, int whence);
 lfs_soff_t lfsr_file_seek(lfs_t *lfs, lfsr_file_t *file,
         lfs_soff_t off, uint8_t whence);
 
@@ -861,7 +840,7 @@ lfs_soff_t lfsr_file_seek(lfs_t *lfs, lfsr_file_t *file,
 // as if the file was filled with zeros.
 //
 // Returns a negative error code on failure.
-int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size);
+//int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size);
 int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size);
 #endif
 
@@ -879,21 +858,21 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size);
 //
 // Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_CUR)
 // Returns the position of the file, or a negative error code on failure.
-lfs_soff_t lfs_file_tell(lfs_t *lfs, lfs_file_t *file);
+//lfs_soff_t lfs_file_tell(lfs_t *lfs, lfs_file_t *file);
 lfs_soff_t lfsr_file_tell(lfs_t *lfs, lfsr_file_t *file);
 
 // Change the position of the file to the beginning of the file
 //
 // Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_SET)
 // Returns a negative error code on failure.
-int lfs_file_rewind(lfs_t *lfs, lfs_file_t *file);
+//int lfs_file_rewind(lfs_t *lfs, lfs_file_t *file);
 int lfsr_file_rewind(lfs_t *lfs, lfsr_file_t *file);
 
 // Return the size of the file
 //
 // Similar to lfs_file_seek(lfs, file, 0, LFS_SEEK_END)
 // Returns the size of the file, or a negative error code on failure.
-lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file);
+//lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file);
 lfs_soff_t lfsr_file_size(lfs_t *lfs, lfsr_file_t *file);
 
 
@@ -903,7 +882,7 @@ lfs_soff_t lfsr_file_size(lfs_t *lfs, lfsr_file_t *file);
 // Create a directory
 //
 // Returns a negative error code on failure.
-int lfs_mkdir(lfs_t *lfs, const char *path);
+//int lfs_mkdir(lfs_t *lfs, const char *path);
 int lfsr_mkdir(lfs_t *lfs, const char *path);
 #endif
 
@@ -911,14 +890,14 @@ int lfsr_mkdir(lfs_t *lfs, const char *path);
 //
 // Once open a directory can be used with read to iterate over files.
 // Returns a negative error code on failure.
-int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path);
+//int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path);
 int lfsr_dir_open(lfs_t *lfs, lfsr_dir_t *dir, const char *path);
 
 // Close a directory
 //
 // Releases any allocated resources.
 // Returns a negative error code on failure.
-int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir);
+//int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir);
 int lfsr_dir_close(lfs_t *lfs, lfsr_dir_t *dir);
 
 // Read an entry in the directory
@@ -926,7 +905,7 @@ int lfsr_dir_close(lfs_t *lfs, lfsr_dir_t *dir);
 // Fills out the info structure, based on the specified file or directory.
 // Returns a positive value on success, 0 at the end of directory,
 // or a negative error code on failure.
-int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info);
+//int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info);
 int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info);
 
 // Change the position of the directory
@@ -935,7 +914,7 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info);
 // an absolute offset in the directory seek.
 //
 // Returns a negative error code on failure.
-int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off);
+//int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off);
 int lfsr_dir_seek(lfs_t *lfs, lfsr_dir_t *dir, lfs_soff_t off);
 
 // Return the position of the directory
@@ -944,13 +923,13 @@ int lfsr_dir_seek(lfs_t *lfs, lfsr_dir_t *dir, lfs_soff_t off);
 // sense, but does indicate the current position in the directory iteration.
 //
 // Returns the position of the directory, or a negative error code on failure.
-lfs_soff_t lfs_dir_tell(lfs_t *lfs, lfs_dir_t *dir);
+//lfs_soff_t lfs_dir_tell(lfs_t *lfs, lfs_dir_t *dir);
 lfs_soff_t lfsr_dir_tell(lfs_t *lfs, lfsr_dir_t *dir);
 
 // Change the position of the directory to the beginning of the directory
 //
 // Returns a negative error code on failure.
-int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir);
+//int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir);
 int lfsr_dir_rewind(lfs_t *lfs, lfsr_dir_t *dir);
 
 
@@ -962,7 +941,7 @@ int lfsr_dir_rewind(lfs_t *lfs, lfsr_dir_t *dir);
 // size may be larger than the filesystem actually is.
 //
 // Returns the number of allocated blocks, or a negative error code on failure.
-lfs_ssize_t lfs_fs_size(lfs_t *lfs);
+//lfs_ssize_t lfs_fs_size(lfs_t *lfs);
 lfs_ssize_t lfsr_fs_size(lfs_t *lfs);
 
 // Traverse through all blocks in use by the filesystem
@@ -972,7 +951,7 @@ lfs_ssize_t lfsr_fs_size(lfs_t *lfs);
 // blocks are in use or how much of the storage is available.
 //
 // Returns a negative error code on failure.
-int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
+//int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
 
 #ifndef LFS_READONLY
 #ifdef LFS_MIGRATE
@@ -987,7 +966,7 @@ int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
 // be zeroed for defaults and backwards compatibility.
 //
 // Returns a negative error code on failure.
-int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg);
+//int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg);
 #endif
 #endif