Cleanup

Bump version
Reorder BIS menu options
2020-03-19 23:01:30 +01:00 · 2020-03-19 16:19:56 +01:00 · 2020-03-19 16:17:36 +01:00 · 2020-03-19 16:11:18 +01:00 · 2020-03-19 13:00:42 +01:00 · 2020-03-19 00:11:18 +01:00
52 changed files with 2581 additions and 1025 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: suchmememanyskill
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
--- a/2
+++ b/2
@@ -10,7 +10,7 @@ include $(DEVKITARM)/base_rules

 IPL_LOAD_ADDR := 0x40003000
 LPVERSION_MAJOR := 2
-LPVERSION_MINOR := 1
+LPVERSION_MINOR := 4
 LPVERSION_BUGFX := 0

 ################################################################################
--- a/README.md
+++ b/README.md
@@ -9,11 +9,13 @@ Navigate around the menu's using the vol+, vol- and power buttons

 ## Functions
 - Navigate the SD card
- Navigate the System partition of your sysnand
+- Navigate the System partition of your sysnand/sysmmc
 - Interact with files
 	- Deleting, copying or moving files
 	- Launching payloads files
 	- Viewing the hex data of a file
+- Interacting with folders
+	- Deleting or copying folders
 - Dumping your current firmware to sd
 - Formatting the sd card

@@ -24,7 +26,7 @@ For general CFW support, go to the [Nintendo Homebrew](https://discord.gg/C29hYv
 For question specifically for TegraExplorer, go to [my discord](https://discord.gg/aH9rsuP)

 # Credits
-Based on [Lockpick_RCM](https://github.com/shchmue/Lockpick_RCM), and thus based on [Hekate](https://github.com/CTCaer/hekate)
+Based on [Lockpick_RCM](https://github.com/shchmue/Lockpick_RCM), and thus also based on [Hekate](https://github.com/CTCaer/hekate)

 Lots of help from:
 - shchmue
--- a/source/gfx/gfx.c
+++ b/source/gfx/gfx.c
@@ -188,7 +188,7 @@ void gfx_putc(char c)

 			for (u32 i = 0; i < 16; i+=2)
 			{
-				u8 v = *cbuf++;
+				u8 v = *cbuf;
 				for (u32 k = 0; k < 2; k++)
 				{
 					for (u32 j = 0; j < 8; j++)
@@ -213,6 +213,7 @@ void gfx_putc(char c)
 					fb += gfx_ctxt.stride - 16;
 					v = *cbuf;
 				}
+				cbuf++;
 			}
 			gfx_con.x += 16;
 			if (gfx_con.x >= gfx_ctxt.width - 16) {
@@ -329,15 +330,10 @@ void gfx_put_big_sep()
 	gfx_con.fntsz = prevFontSize;
 }

-void gfx_printf(const char *fmt, ...)
+void gfx_vprintf(const char *fmt, va_list ap)
 {
-	if (gfx_con.mute)
-		return;
-
-	va_list ap;
 	int fill, fcnt;

-	va_start(ap, fmt);
 	while(*fmt)
 	{
 		if(*fmt == '%')
@@ -389,7 +385,7 @@ void gfx_printf(const char *fmt, ...)
 				gfx_putc('%');
 				break;
 			case '\0':
-				goto out;
+				return;
 			default:
 				gfx_putc('%');
 				gfx_putc(*fmt);
@@ -400,8 +396,17 @@ void gfx_printf(const char *fmt, ...)
 			gfx_putc(*fmt);
 		fmt++;
 	}
+}
+
+void gfx_printf(const char *fmt, ...)
+{
+	if (gfx_con.mute)
+		return;
+
+	va_list ap;
+	va_start(ap, fmt);
+	gfx_vprintf(fmt, ap);

-	out:
 	va_end(ap);
 }

@@ -509,10 +514,10 @@ void gfx_set_rect_grey(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos
 }

 void gfx_box(int x0, int y0, int x1, int y1, u32 color){
-	int i = y0;
-	while(y1 >= i){
-		gfx_line(x0, i, x1, i, color);
-		i++;
+	for (int x = x0; x < x1 + 1; x++){
+		for (int y = y0; y < y1 + 1; y++){
+			gfx_set_pixel(x, y, color);
+		}
 	}
 }

--- a/source/gfx/gfx.h
+++ b/source/gfx/gfx.h
@@ -20,6 +20,7 @@
 #define _GFX_H_

 #include "../../common/common_gfx.h"
+#include <stdarg.h>

 #define EPRINTF(text) gfx_printf("%k"text"%k\n", 0xFFFF0000, 0xFFCCCCCC)
 #define EPRINTFARGS(text, args...) gfx_printf("%k"text"%k\n", 0xFFFF0000, args, 0xFFCCCCCC)
@@ -37,6 +38,7 @@ void gfx_con_setpos(u32 x, u32 y);
 void gfx_putc(char c);
 void gfx_puts(const char *s);
 void gfx_printf(const char *fmt, ...);
+void gfx_vprintf(const char *fmt, va_list ap);
 void gfx_hexdump(u32 base, const u8 *buf, u32 len);

 void gfx_set_pixel(u32 x, u32 y, u32 color);
--- a/source/libs/fatfs/diskio.c
+++ b/source/libs/fatfs/diskio.c
@@ -32,6 +32,7 @@
 #include "../../sec/se.h"
 #include "../../storage/nx_emmc.h"
 #include "../../storage/sdmmc.h"
+#include "../../storage/emummc.h"

 extern sdmmc_storage_t sd_storage;
 extern sdmmc_storage_t storage;
@@ -150,7 +151,7 @@ DRESULT disk_read (
        __attribute__ ((aligned (16))) static u8 tweak[0x10];
        __attribute__ ((aligned (16))) static u64 prev_cluster = -1;
        __attribute__ ((aligned (16))) static u32 prev_sector = 0;
-        bool needs_cache_sector = false;
+        //bool needs_cache_sector = false;
        /*
        if (secindex == 0 || clear_sector_cache) {
            if (!sector_cache)
@@ -212,14 +213,13 @@ DRESULT disk_read (

 DRESULT disk_write (
    BYTE pdrv,			/* Physical drive number to identify the drive */
-    const BYTE *buff,	/* Data to be written */
+    BYTE *buff,	        /* Data to be written */
    DWORD sector,		/* Start sector in LBA */
    UINT count			/* Number of sectors to write */
 )
 {
-    if (pdrv == 1)
-        return RES_WRPRT;
-
+    switch (pdrv){
+        case 0:
            if (((u32)buff >= DRAM_START) && !((u32)buff % 8))
                return sdmmc_storage_write(&sd_storage, sector, count, (void *)buff) ? RES_OK : RES_ERROR;
            u8 *buf = (u8 *)SDMMC_UPPER_BUFFER; //TODO: define this somewhere.
@@ -227,6 +227,33 @@ DRESULT disk_write (
            if (sdmmc_storage_write(&sd_storage, sector, count, buf))
                return RES_OK;
            return RES_ERROR;
+        case 1:;
+            __attribute__ ((aligned (16))) static u8 tweak[0x10];
+            __attribute__ ((aligned (16))) static u64 prev_cluster = -1;
+            __attribute__ ((aligned (16))) static u32 prev_sector = 0;
+            u32 tweak_exp = 0;
+            bool regen_tweak = true;
+
+            if (prev_cluster != sector / 0x20) { // sector in different cluster than last read
+                prev_cluster = sector / 0x20;
+                tweak_exp = sector % 0x20;
+            } else if (sector > prev_sector) { // sector in same cluster and past last sector
+                tweak_exp = sector - prev_sector - 1;
+                regen_tweak = false;
+            } else { // sector in same cluster and before or same as last sector
+                tweak_exp = sector % 0x20;
+            }
+
+            if (_emmc_xts(9, 8, 1, tweak, regen_tweak, tweak_exp, prev_cluster, buff, buff, count * 0x200)){
+                if (nx_emmc_part_write(&storage, system_part, sector, count, buff)){
+                    prev_sector = sector + count - 1;
+                    return RES_OK;
+                }
+            }
+
+            return RES_ERROR;
+    }
+    return RES_ERROR;
 }

 DRESULT disk_ioctl (
--- a/source/libs/fatfs/diskio.h
+++ b/source/libs/fatfs/diskio.h
@@ -31,7 +31,7 @@ typedef enum {
 DSTATUS disk_initialize (BYTE pdrv);
 DSTATUS disk_status (BYTE pdrv);
 DRESULT disk_read (BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
-DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count);
+DRESULT disk_write (BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
 DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);


--- a/source/libs/fatfs/ff.c
+++ b/source/libs/fatfs/ff.c
@@ -39,6 +39,8 @@
 #include "ff.h"			/* Declarations of FatFs API */
 #include "diskio.h"		/* Declarations of device I/O functions */
 #include "../../gfx/gfx.h"
+#include "../../storage/sdmmc.h"
+extern sdmmc_storage_t sd_storage;

 #define EFSPRINTF(text, ...) print_error(); gfx_printf("%k"text"%k\n", 0xFFFFFF00, 0xFFFFFFFF);
 //#define EFSPRINTF(...)
@@ -6105,17 +6107,19 @@ FRESULT f_fdisk (
 	void* work			/* Pointer to the working buffer (null: use heap memory) */
 )
 {
-	UINT i, n, sz_cyl, tot_cyl, b_cyl, e_cyl, p_cyl;
+	UINT i, n, sz_cyl, tot_cyl, e_cyl;
 	BYTE s_hd, e_hd, *p, *buf = (BYTE*)work;
 	DSTATUS stat;
-	DWORD sz_disk, sz_part, s_part;
+	DWORD sz_disk, p_sect, b_cyl, b_sect;
 	FRESULT res;

+	BYTE *empty_buff;
+	empty_buff = ff_memcalloc(sizeof(BYTE), 16384);

 	stat = disk_initialize(pdrv);
 	if (stat & STA_NOINIT) return FR_NOT_READY;
 	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
-	if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &sz_disk)) return FR_DISK_ERR;
+	sz_disk = sd_storage.csd.capacity;

 	buf = (BYTE*)work;
 #if FF_USE_LFN == 3
@@ -6132,20 +6136,25 @@ FRESULT f_fdisk (

 	/* Create partition table */
 	mem_set(buf, 0, FF_MAX_SS);
-	p = buf + MBR_Table; b_cyl = 0;
+	p = buf + MBR_Table; b_cyl = 0, b_sect = 0;
 	for (i = 0; i < 4; i++, p += SZ_PTE) {
-		p_cyl = (szt[i] <= 100U) ? (DWORD)tot_cyl * (szt[i] / 100) : szt[i] / sz_cyl;	/* Number of cylinders */
-		if (p_cyl == 0) continue;
-		s_part = (DWORD)sz_cyl * b_cyl;
-		sz_part = (DWORD)sz_cyl * p_cyl;
-		if (i == 0) {	/* Exclude first track of cylinder 0 */
+		p_sect = szt[i]; /* Number of sectors */
+
+		if (p_sect == 0) 
+			continue;
+		
+		if (i == 0) {	/* Exclude first 16MiB of sd */
 			s_hd = 1;
-			s_part += 32768; sz_part -= 32768;
-		} else {
-			s_hd = 0;
+			b_sect += 32768; p_sect -= 32768;
 		} 
-		e_cyl = b_cyl + p_cyl - 1;	/* End cylinder */
-		if (e_cyl >= tot_cyl) LEAVE_MKFS(FR_INVALID_PARAMETER);
+		else
+			s_hd = 0;
+		
+		b_cyl = b_sect / sz_cyl;
+		e_cyl = ((b_sect + p_sect) / sz_cyl) - 1;	/* End cylinder */
+
+		if (e_cyl >= tot_cyl)
+			LEAVE_MKFS(FR_INVALID_PARAMETER);


 		/* Set partition table */
@@ -6156,12 +6165,17 @@ FRESULT f_fdisk (
 		p[5] = e_hd;						/* End head */
 		p[6] = (BYTE)(((e_cyl >> 2) & 0xC0) | 63);	/* End sector */
 		p[7] = (BYTE)e_cyl;					/* End cylinder */
-		st_dword(p + 8, s_part);			/* Start sector in LBA */
-		st_dword(p + 12, sz_part);			/* Number of sectors */
+		st_dword(p + 8, b_sect);			/* Start sector in LBA */
+		st_dword(p + 12, p_sect);			/* Number of sectors */
 		/* Next partition */
-		b_cyl += p_cyl;
+		b_sect += p_sect;
+
+		for (int cursect = 0; cursect < 1024; cursect++){
+			disk_write(pdrv, empty_buff, b_sect + (32 * cursect), 32);
+		}
 	}
 	st_word(p, 0xAA55);		/* MBR signature (always at offset 510) */
+	ff_memfree(empty_buff);

 	/* Write it to the MBR */
 	res = (disk_write(pdrv, buf, 0, 1) == RES_OK && disk_ioctl(pdrv, CTRL_SYNC, 0) == RES_OK) ? FR_OK : FR_DISK_ERR;
--- a/source/libs/fatfs/ff.h
+++ b/source/libs/fatfs/ff.h
@@ -321,6 +321,7 @@ DWORD ff_wtoupper (DWORD uni);			/* Unicode upper-case conversion */
 #endif
 #if FF_USE_LFN == 3						/* Dynamic memory allocation */
 void* ff_memalloc (UINT msize);			/* Allocate memory block */
+void* ff_memcalloc (UINT msize, UINT amount);
 void ff_memfree (void* mblock);			/* Free memory block */
 #endif

--- a/source/libs/fatfs/ffsystem.c
+++ b/source/libs/fatfs/ffsystem.c
@@ -23,6 +23,10 @@ void* ff_memalloc (	/* Returns pointer to the allocated memory block (null if no
 	return malloc(msize);	/* Allocate a new memory block with POSIX API */
 }

+void* ff_memcalloc (UINT msize, UINT amount){
+	return calloc(amount, msize);
+}
+

 /*------------------------------------------------------------------------*/
 /* Free a memory block                                                    */
--- a/source/main.c
+++ b/source/main.c
@@ -38,7 +38,7 @@
 #include "utils/dirlist.h"
 #include "utils/sprintf.h"
 #include "utils/util.h"
-#include "tegraexplorer/te.h"
+#include "tegraexplorer/mainmenu.h"

 //#include "keys/keys.h"

@@ -52,10 +52,10 @@ boot_cfg_t __attribute__((section ("._boot_cfg"))) b_cfg;

 bool return_sd_mounted(int value){
 	switch(value){
-		case 1:
-			return sd_mounted;
-		case 7:
+		case 10:
 			return sd_inited;
+		default:
+			return sd_mounted;
 	}
 }

--- a/source/mem/minerva.c
+++ b/source/mem/minerva.c
@@ -32,6 +32,7 @@ u32 minerva_init()
 {
 	u32 curr_ram_idx = 0;

+	minerva_cfg = NULL;
 	mtc_config_t *mtc_cfg = (mtc_config_t *)&nyx_str->mtc_cfg;

 	// Set table to nyx storage.
--- a/source/storage/emummc.c
+++ b/source/storage/emummc.c
@@ -139,7 +139,6 @@ out:

 int emummc_storage_end(sdmmc_storage_t *storage)
 {
-	sd_unmount();
 	sdmmc_storage_end(storage);

 	return 1;
--- a/source/storage/nx_emmc.c
+++ b/source/storage/nx_emmc.c
@@ -74,5 +74,5 @@ int nx_emmc_part_write(sdmmc_storage_t *storage, emmc_part_t *part, u32 sector_o
 	// The last LBA is inclusive.
 	if (part->lba_start + sector_off > part->lba_end)
 		return 0;
-	return sdmmc_storage_write(storage, part->lba_start + sector_off, num_sectors, buf);
+	return emummc_storage_write(storage, part->lba_start + sector_off, num_sectors, buf);
 }
--- a/source/tegraexplorer/common/common.h
+++ b/source/tegraexplorer/common/common.h
@@ -0,0 +1,105 @@
+#pragma once
+#include "types.h"
+
+extern const char *gfx_file_size_names[];
+extern const char *menu_sd_states[];
+extern const char *emmc_fs_entries[];
+extern const char *utils_err_codes[];
+extern const char *pkg2names[];
+extern const char *mainmenu_credits;
+
+enum utils_err_codes_te_call {
+    ERR_SAME_LOC = 50,
+    ERR_DISK_WRITE_FAILED,
+    ERR_EMPTY_CLIPBOARD,
+    ERR_FOLDER_ROOT = 54,
+    ERR_DEST_PART_OF_SRC,
+    ERR_PART_NOT_FOUND,
+    ERR_BISKEY_DUMP_FAILED,
+    ERR_MEM_ALLOC_FAILED,
+    ERR_EMMC_READ_FAILED,
+    ERR_EMMC_WRITE_FAILED,
+    ERR_FILE_TOO_BIG_FOR_DEST
+};
+
+extern const char *utils_err_codes_te[];
+
+enum mainmenu_main_return {
+    MAIN_SDCARD = 0,
+    MAIN_EMMC_SAF,
+    MAIN_EMMC_SYS,
+    MAIN_EMMC_USR,
+    MAIN_EMUMMC_SAF,
+    MAIN_EMUMMC_SYS,
+    MAIN_EMUMMC_USR,
+    MAIN_MOUNT_SD,
+    MAIN_TOOLS,
+    MAIN_SD_FORMAT,
+    MAIN_CREDITS,
+    MAIN_EXIT
+};
+
+extern menu_entry mainmenu_main[];
+
+enum mainmenu_shutdown_return {
+    SHUTDOWN_REBOOT_RCM = 1,
+    SHUTDOWN_REBOOT_NORMAL,
+    SHUTDOWN_POWER_OFF,
+    SHUTDOWN_HEKATE,
+    SHUTDOWN_AMS
+};
+
+extern menu_entry mainmenu_shutdown[];
+
+enum mainmenu_tools_return {
+    TOOLS_DISPLAY_INFO = 1,
+    TOOLS_DISPLAY_GPIO,
+    TOOLS_DUMPFIRMWARE,
+    TOOLS_DUMPUSERSAVE,
+    TOOLS_DUMP_BOOT
+};
+
+extern menu_entry mainmenu_tools[];
+
+enum mainmenu_format_return {
+    FORMAT_ALL_FAT32 = 1,
+    FORMAT_EMUMMC
+};
+
+extern menu_entry mainmenu_format[];
+
+enum mmc_types {
+    SYSMMC = 1,
+    EMUMMC
+};
+
+extern menu_entry utils_mmcChoice[];
+
+enum fs_menu_file_return {
+    FILE_COPY = 4,
+    FILE_MOVE,
+    FILE_DELETE,
+    FILE_PAYLOAD,
+    FILE_SCRIPT,
+    FILE_HEXVIEW,
+    FILE_DUMPBIS,
+    FILE_RESTOREBIS
+};
+
+extern menu_entry fs_menu_file[];
+
+enum fs_menu_folder_return {
+    DIR_EXITFOLDER = 2,
+    DIR_COPYFOLDER,
+    DIR_DELETEFOLDER
+};
+
+extern menu_entry fs_menu_folder[];
+
+enum fs_menu_startdir_return {
+    FILEMENU_RETURN = 0,
+    FILEMENU_CLIPBOARD,
+    FILEMENU_CURFOLDER
+};
+
+extern menu_entry fs_menu_startdir[];
--- a/source/tegraexplorer/common/strings.c
+++ b/source/tegraexplorer/common/strings.c
@@ -0,0 +1,63 @@
+#include "common.h"
+
+const char *gfx_file_size_names[] = {
+    "B ",
+    "KB",
+    "MB",
+    "GB"
+};
+
+const char *menu_sd_states[] = {
+    "\nUnmount SD",
+    "\nMount SD"
+};
+
+const char *emmc_fs_entries[] = {
+    "SAFE",
+    "SYSTEM",
+    "USER"
+};
+
+const char *utils_err_codes[] = {
+    "OK",
+    "I/O ERROR",
+    "NO DISK",
+    "NOT READY",
+    "NO FILE",
+    "NO PATH",
+    "PATH INVALID",
+    "ACCESS DENIED",
+    "ACCESS DENIED",
+    "INVALID PTR",
+    "PROTECTED",
+    "INVALID DRIVE",
+    "NO MEM",
+    "NO FAT",
+    "MKFS ABORT"
+};
+
+const char *utils_err_codes_te[] = { // these start at 50
+    "SAME LOC",
+    "DISK WRITE FAILED",
+    "EMPTY CLIPBOARD",
+    "DEFENITION OF INSANITY",
+    "FOLDER ROOT",
+    "DEST PART OF SRC",
+    "PART NOT FOUND",
+    "BISKEY DUMP FAILED",
+    "MEM ALLOC FAILED",
+    "EMMC READ FAILED",
+    "EMMC WRITE FAILED",
+    "FILE TOO BIG FOR DEST"
+};
+
+const char *pkg2names[] = {
+    "BCPKG2-1-Normal-Main",
+    "BCPKG2-2-Normal-Sub",
+    "BCPKG2-3-SafeMode-Main",
+    "BCPKG2-4-SafeMode-Sub",
+    "BCPKG2-5-Repair-Main",
+    "BCPKG2-6-Repair-Sub"
+};
+
+const char *mainmenu_credits = "\nTegraexplorer, made by:\nSuch Meme, Many Skill\n\nProject based on:\nLockpick_RCM\nHekate\n\nCool people:\nshchmue\ndennthecafebabe\nDax";
--- a/source/tegraexplorer/common/structs.c
+++ b/source/tegraexplorer/common/structs.c
@@ -0,0 +1,76 @@
+#include "common.h"
+#include "types.h"
+
+menu_entry mainmenu_main[] = {
+    {"[SD:/] SD CARD\n", COLOR_GREEN, ISMENU},
+    {"[SAFE:/] EMMC", COLOR_ORANGE, ISMENU},
+    {"[SYSTEM:/] EMMC", COLOR_ORANGE, ISMENU},
+    {"[USER:/] EMMC", COLOR_ORANGE, ISMENU},
+    {"\n[SAFE:/] EMUMMC", COLOR_BLUE, ISMENU},
+    {"[SYSTEM:/] EMUMMC", COLOR_BLUE, ISMENU},
+    {"[USER:/] EMUMMC", COLOR_BLUE, ISMENU},
+    {"\nMount/Unmount SD", COLOR_WHITE, ISMENU},
+    {"Tools", COLOR_VIOLET, ISMENU},
+    {"SD format", COLOR_VIOLET, ISMENU},
+    {"\nCredits", COLOR_WHITE, ISMENU},
+    {"Exit", COLOR_WHITE, ISMENU}
+};
+
+menu_entry mainmenu_shutdown[] = {
+    {"Back", COLOR_WHITE, ISMENU},
+    {"\nReboot to RCM", COLOR_VIOLET, ISMENU},
+    {"Reboot normally", COLOR_ORANGE, ISMENU},
+    {"Power off\n", COLOR_BLUE, ISMENU},
+    {"Reboot to Hekate", COLOR_GREEN, ISMENU},
+    {"Reboot to Atmosphere", COLOR_GREEN, ISMENU}
+};
+
+menu_entry mainmenu_tools[] = {
+    {"Back", COLOR_WHITE, ISMENU},
+    {"\nDisplay Console Info", COLOR_GREEN, ISMENU},
+    {"Display GPIO pins", COLOR_VIOLET, ISMENU},
+    {"Dump Firmware", COLOR_BLUE, ISMENU},
+    {"Dump User Saves", COLOR_YELLOW, ISMENU},
+    {"Dump bis", COLOR_ORANGE, ISMENU}
+};
+
+menu_entry mainmenu_format[] = {
+    {"Back\n", COLOR_WHITE, ISMENU},
+    {"Format entire SD to FAT32", COLOR_RED, ISMENU},
+    {"Format for EmuMMC setup (FAT32/RAW)", COLOR_RED, ISMENU}
+};
+
+menu_entry utils_mmcChoice[] = {
+    {"Back\n", COLOR_WHITE, ISMENU},
+    {"SysMMC", COLOR_ORANGE, ISMENU},
+    {"EmuMMC", COLOR_BLUE, ISMENU}
+};
+
+menu_entry fs_menu_file[] = {
+    {NULL, COLOR_GREEN, ISMENU | ISSKIP},
+    {NULL, COLOR_VIOLET, ISMENU | ISSKIP},
+    {NULL, COLOR_VIOLET, ISMENU | ISSKIP},
+    {"\n\n\nBack", COLOR_WHITE, ISMENU},
+    {"\nCopy to clipboard", COLOR_BLUE, ISMENU},
+    {"Move to clipboard", COLOR_BLUE, ISMENU},
+    {"\nDelete file\n", COLOR_RED, ISMENU},
+    {"Launch Payload", COLOR_ORANGE, ISMENU},
+    {"Launch Script", COLOR_YELLOW, ISMENU},
+    {"View Hex", COLOR_GREEN, ISMENU},
+    {"\nExtract BIS", COLOR_YELLOW, ISMENU},
+    {"Restore BIS", COLOR_RED, ISMENU}
+};
+
+menu_entry fs_menu_folder[] = {
+    {NULL, COLOR_VIOLET, ISMENU | ISSKIP},
+    {"\nBack", COLOR_WHITE, ISMENU},
+    {"Return to main menu\n", COLOR_BLUE, ISMENU},
+    {"Copy to clipboard", COLOR_VIOLET, ISMENU},
+    {"Delete folder", COLOR_RED, ISMENU}
+};
+
+menu_entry fs_menu_startdir[] = {
+    {"Folder -> previous folder            ", COLOR_ORANGE, ISMENU},
+    {"Clipboard -> Current folder          ", COLOR_ORANGE, ISMENU},
+    {"Current folder menu                  ", COLOR_ORANGE, ISMENU}
+};
--- a/source/tegraexplorer/common/types.h
+++ b/source/tegraexplorer/common/types.h
@@ -0,0 +1,46 @@
+#pragma once
+#include "../../utils/types.h"
+
+#define ISDIR (1 << 0)
+#define ISARC (1 << 1)
+
+#define ISHIDE (1 << 8)
+#define ISMENU (1 << 9)
+#define ISSKIP (1 << 10)
+
+#define ISGB (1 << 7)
+#define ISMB (1 << 6)
+#define ISKB (1 << 5)
+#define ISB  (1 << 4)
+
+#define SETBIT(object, shift, value) ((value) ? (object |= shift) : (object &= ~shift))
+
+/* Bit table for property as a file:
+0000 0001: Directory bit
+0000 0010: Archive bit (or hideme)
+0001 0000: Size component is a Byte
+0010 0000: Size component is a KiloByte
+0100 0000: Size component is a MegaByte
+1000 0000: Size component is a GigaByte : note that this won't surpass gigabytes, but i don't expect people to have a single file that's a terrabyte big
+*/
+
+#define COPY_MODE_PRINT 0x1
+#define COPY_MODE_CANCEL 0x2
+#define BUFSIZE 32768
+
+#define OPERATIONCOPY 0x2
+#define OPERATIONMOVE 0x4
+
+#define PART_BOOT 0x1
+#define PART_PKG2 0x2
+
+#define BOOT0_ARG 0x80
+#define BOOT1_ARG 0x40
+#define BCPKG2_1_ARG 0x20
+#define BCPKG2_3_ARG 0x10
+
+typedef struct {
+    char *name;
+    u32 storage;
+    u16 property;
+} menu_entry; 
--- a/source/tegraexplorer/emmc/emmc.c
+++ b/source/tegraexplorer/emmc/emmc.c
@@ -1,34 +1,39 @@
 #include <string.h>
-#include "../mem/heap.h"
-#include "gfx.h"
-#include "fs.h"
 #include "emmc.h"
-#include "../utils/types.h"
-#include "../libs/fatfs/ff.h"
-#include "../utils/sprintf.h"
-#include "../utils/btn.h"
-#include "../gfx/gfx.h"
-#include "../utils/util.h"
-#include "../hos/pkg1.h"
-#include "../storage/sdmmc.h"
-#include "../storage/nx_emmc.h"
-#include "../sec/tsec.h"
-#include "../soc/t210.h"
-#include "../soc/fuse.h"
-#include "../mem/mc.h"
-#include "../sec/se.h"
-#include "../soc/hw_init.h"
-#include "../mem/emc.h"
-#include "../mem/sdram.h"
+#include "../../mem/heap.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/sprintf.h"
+#include "../../utils/btn.h"
+#include "../../gfx/gfx.h"
+#include "../../utils/util.h"
+#include "../../hos/pkg1.h"
+#include "../../storage/sdmmc.h"
+#include "../../storage/nx_emmc.h"
+#include "../../sec/tsec.h"
+#include "../../soc/t210.h"
+#include "../../soc/fuse.h"
+#include "../../mem/mc.h"
+#include "../../sec/se.h"
+#include "../../soc/hw_init.h"
+#include "../../mem/emc.h"
+#include "../../mem/sdram.h"
+#include "../../storage/emummc.h"
+#include "../../config/config.h"
+#include "../common/common.h"
+#include "../gfx/gfxutils.h"

 sdmmc_storage_t storage;
 emmc_part_t *system_part;
 sdmmc_t sdmmc;
+extern hekate_config h_cfg;
 __attribute__ ((aligned (16))) FATFS emmc;
 LIST_INIT(gpt);

 u8 bis_key[4][32];
-short pkg1ver = -1;
+pkg1_info pkg1inf = {-1, ""};
+short currentlyMounted = -1;
+

 static bool  _key_exists(const void *data) { return memcmp(data, zeros, 0x10); };

@@ -52,32 +57,71 @@ void print_biskeys(){
    gfx_hexdump(0, bis_key[2], 32);
 }

-int mount_emmc(char *partition, int biskeynumb){
-    f_unmount("emmc:");
+pkg1_info returnpkg1info(){
+    return pkg1inf;
+}

-    se_aes_key_set(8, bis_key[biskeynumb] + 0x00, 0x10);
-    se_aes_key_set(9, bis_key[biskeynumb] + 0x10, 0x10);
+int connect_part(const char *partition){
+    sdmmc_storage_set_mmc_partition(&storage, 0);

    system_part = nx_emmc_part_find(&gpt, partition);
    if (!system_part) {
-        gfx_printf("Failed to locate %s partition.", partition);
-        return -1;
-    }
-
-    if (f_mount(&emmc, "emmc:", 1)) {
-        gfx_printf("Mount failed of %s.", partition);
+        gfx_errDisplay("connect_mmc_part", ERR_PART_NOT_FOUND, 0);
        return -1;
    }

    return 0;
 }

-short returnpkg1ver(){
-    return pkg1ver;
+int mount_mmc(const char *partition, const int biskeynumb){
+    int res;
+    f_unmount("emmc:");
+    
+    se_aes_key_set(8, bis_key[biskeynumb] + 0x00, 0x10);
+    se_aes_key_set(9, bis_key[biskeynumb] + 0x10, 0x10);
+
+    if (connect_part(partition))
+        return -1;
+
+    if ((res = f_mount(&emmc, "emmc:", 1))) {
+        gfx_errDisplay("mount_mmc", res, 0);
+        return -1;
    } 

-void disconnect_emmc(){
+    return 0;
+}
+
+void connect_mmc(short mmctype){
+    if (mmctype != currentlyMounted){
+        disconnect_mmc();
+        h_cfg.emummc_force_disable = 0;
+        switch (mmctype){
+            case SYSMMC:
+                sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4);
+                h_cfg.emummc_force_disable = 1;
+                currentlyMounted = SYSMMC;
+                break;
+            case EMUMMC:
+                if (emummc_storage_init_mmc(&storage, &sdmmc)){
+                    h_cfg.emummc_force_disable = 0;
+                    currentlyMounted = EMUMMC;
+                }
+                break;
+        }
+    }
+}
+
+void disconnect_mmc(){
+    f_unmount("emmc:");
+    switch (currentlyMounted){
+        case SYSMMC:
            sdmmc_storage_end(&storage);
+            break;
+        case EMUMMC:
+            emummc_storage_end(&storage);
+            break;
+    }
+    currentlyMounted = -1;
 }

 int dump_biskeys(){
@@ -86,7 +130,7 @@ int dump_biskeys(){

 	int retries = 0;

-    sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4);
+    connect_mmc(SYSMMC);

    // Read package1.
    u8 *pkg1 = (u8 *)malloc(0x40000);
@@ -171,41 +215,11 @@ int dump_biskeys(){
    sdmmc_storage_set_mmc_partition(&storage, 0);
    // Parse eMMC GPT.
    nx_emmc_gpt_parse(&gpt, &storage);
-    /*
-    char part_name[37] = "SYSTEM";

-    // todo: menu selection for this
-
-    u32 bis_key_index = 0;
-    if (strcmp(part_name, "PRODINFOF") == 0)
-        bis_key_index = 0;
-    else if (strcmp(part_name, "SAFE") == 0)
-        bis_key_index = 1;
-    else if (strcmp(part_name, "SYSTEM") == 0)
-        bis_key_index = 2;
-    else if (strcmp(part_name, "USER") == 0)
-        bis_key_index = 3;
-    else {
-        gfx_printf("Partition name %s unrecognized.", part_name);
-        return;
-    }
-    */
    se_aes_key_set(8, bis_key[2] + 0x00, 0x10);
    se_aes_key_set(9, bis_key[2] + 0x10, 0x10);
    
-    /*
-    system_part = nx_emmc_part_find(&gpt, "SYSTEM");
-    if (!system_part) {
-        gfx_printf("Failed to locate SYSTEM partition.");
-        return -1;
-    }
-
-    if (f_mount(&emmc_sys, "system:", 1)) {
-        gfx_printf("Mount failed of SYSTEM.");
-        return -1;
-    }
-    */
-
-    pkg1ver = pkg1_id->kb;
+    pkg1inf.ver = pkg1_id->kb;
+    strcpy(pkg1inf.id, pkg1_id->id);
    return 0;
 }
--- a/source/tegraexplorer/emmc/emmc.h
+++ b/source/tegraexplorer/emmc/emmc.h
@@ -1,11 +1,20 @@
 #pragma once
+#include "../../utils/types.h"
+
+typedef struct _pkg1_info {
+    short ver;
+    char id[16];
+} pkg1_info;

 //int mount_emmc_partition(const char *part, int logicnumb);
 int dump_biskeys();
 void print_biskeys();
-int mount_emmc(char *partition, int biskeynumb);
-short returnpkg1ver();
-void disconnect_emmc();
+pkg1_info returnpkg1info();
+
+int mount_mmc(const char *partition, const int biskeynumb);
+void connect_mmc(short mmctype);
+void disconnect_mmc();
+int connect_part(const char *partition);

 static const u8 zeros[0x10] = {0};

@@ -41,3 +50,10 @@ static const u8 bis_key_source[3][0x20] = {
        0x52, 0xC2, 0xE9, 0xEB, 0x09, 0xE3, 0xEE, 0x29, 0x32, 0xA1, 0x0C, 0x1F, 0xB6, 0xA0, 0x92, 0x6C,
        0x4D, 0x12, 0xE1, 0x4B, 0x2A, 0x47, 0x4C, 0x1C, 0x09, 0xCB, 0x03, 0x59, 0xF0, 0x15, 0xF4, 0xE4}
 };
+
+/*
+enum mmc_types {
+    SYSMMC = 0,
+    EMUMMC
+};
+*/
--- a/source/tegraexplorer/emmc/emmcdumpbis.c
+++ b/source/tegraexplorer/emmc/emmcdumpbis.c
@@ -0,0 +1,120 @@
+#include <string.h>
+#include "emmcoperations.h"
+#include "../../gfx/gfx.h"
+#include "../gfx/gfxutils.h"
+#include "../../utils/types.h"
+#include "emmc.h"
+#include "../../storage/emummc.h"
+#include "../common/common.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/sprintf.h"
+#include "../../utils/btn.h"
+#include "../../mem/heap.h"
+#include "../../storage/nx_emmc.h"
+#include "../common/types.h"
+#include "../utils/utils.h"
+#include "../fs/fsutils.h"
+
+extern sdmmc_storage_t storage;
+extern emmc_part_t *system_part;
+
+int dump_emmc_part(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part){
+    FIL fp;
+    u8 *buf;
+	u32 lba_curr = part->lba_start;
+	u32 bytesWritten = 0;
+    u32 totalSectors = part->lba_end - part->lba_start + 1;
+    u64 totalSize = (u64)((u64)totalSectors << 9);
+    u32 num = 0;
+    u32 pct = 0;
+    int res;
+
+    gfx_printf("Initializing\r");
+    buf = calloc(BUFSIZE, sizeof(u8));
+
+    if (!buf){
+        gfx_errDisplay("dump_emmc_part", ERR_MEM_ALLOC_FAILED, 1);
+        return -1;
+    }
+
+    if ((res = f_open(&fp, path, FA_CREATE_ALWAYS | FA_WRITE))){
+        gfx_errDisplay("dump_emmc_part", res, 2);
+        return -1;
+    }
+
+    f_lseek(&fp, totalSize);
+    f_lseek(&fp, 0);
+
+    while (totalSectors > 0){
+        num = MIN(totalSectors, 64);
+        if (!emummc_storage_read(mmcstorage, lba_curr, num, buf)){
+            gfx_errDisplay("dump_emmc_part", ERR_EMMC_READ_FAILED, 3);
+            return -1;
+        }
+        if ((res = f_write(&fp, buf, num * NX_EMMC_BLOCKSIZE, NULL))){
+            gfx_errDisplay("dump_emmc_part", res, 4);
+            return -1;
+        }
+        pct = (u64)((u64)(lba_curr - part->lba_start) * 100u) / (u64)(part->lba_end - part->lba_start);
+        gfx_printf("Progress: %d%%\r", pct);
+
+        lba_curr += num;
+        totalSectors -= num;
+        bytesWritten += num * NX_EMMC_BLOCKSIZE;
+    }
+    gfx_printf("                \r");
+    f_close(&fp);
+    free(buf);
+    return 0;
+}
+
+int dump_emmc_parts(u16 parts, u8 mmctype){
+    char *path;
+    char basepath[] = "sd:/tegraexplorer/dumps";
+    f_mkdir("sd:/tegraexplorer");
+    f_mkdir("sd:/tegraexplorer/dumps");
+
+    connect_mmc(mmctype);
+    gfx_clearscreen();
+
+    if (parts & PART_BOOT){
+        emmc_part_t bootPart;
+        const u32 BOOT_PART_SIZE = storage.ext_csd.boot_mult << 17;
+        memset(&bootPart, 0, sizeof(bootPart));
+        
+        bootPart.lba_start = 0;
+        bootPart.lba_end = (BOOT_PART_SIZE / NX_EMMC_BLOCKSIZE) - 1;
+        
+        for (int i = 0; i < 2; i++){
+            strcpy(bootPart.name, "BOOT");
+            bootPart.name[4] = (u8)('0' + i);
+		    bootPart.name[5] = 0;     
+
+            emummc_storage_set_mmc_partition(&storage, i + 1);
+            utils_copystring(fsutil_getnextloc(basepath, bootPart.name), &path);
+            gfx_printf("Dumping %s\n", bootPart.name);
+ 
+            dump_emmc_part(path, &storage, &bootPart);
+            free(path);
+        }
+    }
+
+    if (parts & PART_PKG2){
+        for (int i = 0; i < 6; i++){
+            if (connect_part(pkg2names[i])){
+                gfx_errDisplay("dump_emmc_parts", ERR_PART_NOT_FOUND, 0);
+                return -1;
+            }
+
+            utils_copystring(fsutil_getnextloc(basepath, system_part->name), &path);
+            gfx_printf("Dumping %s\n", system_part->name);
+
+            dump_emmc_part(path, &storage, system_part);
+            free(path);
+        }
+    }
+
+    gfx_printf("\nDone!");
+    btn_wait();
+    return 0;
+}
--- a/source/tegraexplorer/emmc/emmcoperations.h
+++ b/source/tegraexplorer/emmc/emmcoperations.h
@@ -0,0 +1,5 @@
+#pragma once
+#include "../../utils/types.h"
+
+int dump_emmc_parts(u16 parts, u8 mmctype);
+int restore_bis_using_file(char *path, u8 mmctype);
--- a/source/tegraexplorer/emmc/emmcrestorebis.c
+++ b/source/tegraexplorer/emmc/emmcrestorebis.c
@@ -0,0 +1,167 @@
+#include <string.h>
+#include "emmcoperations.h"
+#include "../../gfx/gfx.h"
+#include "../gfx/gfxutils.h"
+#include "../../utils/types.h"
+#include "emmc.h"
+#include "../../storage/emummc.h"
+#include "../common/common.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/sprintf.h"
+#include "../../utils/btn.h"
+#include "../../mem/heap.h"
+#include "../../storage/nx_emmc.h"
+#include "../common/types.h"
+#include "../utils/utils.h"
+#include "../fs/fsutils.h"
+
+extern sdmmc_storage_t storage;
+extern emmc_part_t *system_part;
+
+int restore_emmc_part(char *path, sdmmc_storage_t *mmcstorage, emmc_part_t *part){
+    FIL fp;
+    FILINFO fno;
+    u8 *buf;
+	u32 lba_curr = part->lba_start;
+	u32 bytesWritten = 0;
+    u32 totalSectorsDest = part->lba_end - part->lba_start + 1;
+    u64 totalSizeDest = (u64)((u64)totalSectorsDest << 9);
+    u64 totalSize;
+    u32 num = 0;
+    u32 pct = 0;
+    int res;
+
+    gfx_printf("Initializing\r");
+
+    buf = calloc(16384, sizeof(u8));
+
+    if (!buf){
+        gfx_errDisplay("restore_emmc_part", ERR_MEM_ALLOC_FAILED, 1);
+        return -1;
+    }
+
+    if ((res = f_stat(path, &fno))){
+        gfx_errDisplay("restore_emmc_part", res, 2);
+        return -1;
+    }
+
+    totalSize = fno.fsize;
+    u64 totalSectors = totalSize / NX_EMMC_BLOCKSIZE;
+
+    if (totalSize > totalSizeDest){
+        gfx_errDisplay("restore_emmc_part", ERR_FILE_TOO_BIG_FOR_DEST, 3);
+        return -1;
+    }
+
+    gfx_printf("Flashing %s\n", part->name);
+
+    if (totalSize < totalSizeDest){
+        SWAPCOLOR(COLOR_ORANGE);
+        gfx_printf("File is too small for destenation.\nDo you want to flash it anyway?\n\nVol +/- to Cancel\n");
+        u8 btnres = gfx_makewaitmenu(
+            "Power to Confirm",
+            2
+        );
+
+        RESETCOLOR;
+
+        if (!btnres){
+            gfx_printf("\nCancelled: %s\n\n", part->name);
+            return 0;
+        }
+        else
+            gfx_printf("\nFlashing %s\n", part->name);
+    }
+
+    if ((res = f_open(&fp, path, FA_OPEN_ALWAYS | FA_READ))){
+        gfx_errDisplay("restore_emmc_part", res, 4);
+        return -1;
+    }
+
+    while (totalSectors > 0){
+        num = MIN(totalSectors, 32);
+
+        if ((res = f_read(&fp, buf, num * NX_EMMC_BLOCKSIZE, NULL))){
+            gfx_errDisplay("restore_emmc_part", res, 5);
+            return -1;
+        }
+
+        if (!emummc_storage_write(mmcstorage, lba_curr, num, buf)){
+            gfx_errDisplay("restore_emmc_part", ERR_EMMC_WRITE_FAILED, 2);
+            return -1;
+        }
+
+        lba_curr += num;
+        totalSectors -= num;
+        bytesWritten += num * NX_EMMC_BLOCKSIZE;
+
+        pct = (u64)((u64)(bytesWritten) * 100u) / (u64)(fno.fsize);
+        gfx_printf("Progress: %d%%\r", pct);
+    }
+
+    gfx_printf("                \r");
+    f_close(&fp);
+    free(buf);
+    return 0;
+}
+
+int restore_emmc_file(char *path, const char *target, u8 partition, u8 mmctype){
+    connect_mmc(mmctype);
+
+    if (partition){
+        emmc_part_t bootPart;
+        const u32 BOOT_PART_SIZE = storage.ext_csd.boot_mult << 17;
+        memset(&bootPart, 0, sizeof(bootPart));
+
+        bootPart.lba_start = 0;
+        bootPart.lba_end = (BOOT_PART_SIZE / NX_EMMC_BLOCKSIZE) - 1;
+
+        strcpy(bootPart.name, target);
+
+        emummc_storage_set_mmc_partition(&storage, partition);
+        restore_emmc_part(path, &storage, &bootPart);
+    }
+    else {
+        if (connect_part(target)){
+            gfx_errDisplay("restore_emmc_part", ERR_PART_NOT_FOUND, 0);
+            return -1;
+        }
+        restore_emmc_part(path, &storage, system_part);
+    }
+    return 0;
+}
+
+int restore_bis_using_file(char *path, u8 mmctype){
+    f_mkdir("sd:/tegraexplorer");
+    f_mkdir("sd:/tegraexplorer/bis");
+    gfx_clearscreen();
+
+    if (extract_bis_file(path, "sd:/tegraexplorer/bis"))
+        return -1;
+
+    SWAPBGCOLOR(COLOR_RED);
+    SWAPCOLOR(COLOR_DEFAULT);
+    gfx_printf("\nAre you sure you want to flash these files\nThis could leave your switch unbootable!\nTarget is SysMMC\n\nVol +/- to cancel\n");
+    if (!gfx_makewaitmenu(
+        "Power to confirm",
+        10
+    ))
+    {
+        return 0;
+    }
+    RESETCOLOR;
+
+    gfx_printf("\nRestoring BIS...\n\n");
+
+    restore_emmc_file("sd:/tegraexplorer/bis/BOOT0.bin", "BOOT0", 1, mmctype);
+    restore_emmc_file("sd:/tegraexplorer/bis/BOOT1.bin", "BOOT1", 2, mmctype);
+    restore_emmc_file("sd:/tegraexplorer/bis/BCPKG2-1-Normal-Main", pkg2names[0], 0, mmctype);
+    restore_emmc_file("sd:/tegraexplorer/bis/BCPKG2-1-Normal-Main", pkg2names[1], 0, mmctype);
+    restore_emmc_file("sd:/tegraexplorer/bis/BCPKG2-3-SafeMode-Main", pkg2names[2], 0, mmctype);
+    restore_emmc_file("sd:/tegraexplorer/bis/BCPKG2-3-SafeMode-Main", pkg2names[3], 0, mmctype);
+
+    gfx_printf("\n\nDone!\nPress any button to return");
+    btn_wait();
+
+    return 0;
+}
--- a/source/tegraexplorer/fs.c
+++ b/source/tegraexplorer/fs.c
@@ -1,399 +0,0 @@
-#include <string.h>
-#include "../mem/heap.h"
-#include "gfx.h"
-#include "fs.h"
-#include "../utils/types.h"
-#include "../libs/fatfs/ff.h"
-#include "../utils/sprintf.h"
-#include "../utils/btn.h"
-#include "../gfx/gfx.h"
-#include "../utils/util.h"
-
-fs_entry fileobjects[500];
-char rootpath[10] = "";
-char *currentpath = "";
-char *clipboard = "";
-u8 clipboardhelper = 0;
-extern const char sizevalues[4][3];
-extern int launch_payload(char *path);
-
-menu_item explfilemenu[9] = {
-    {"-- File Menu --", COLOR_BLUE, -1, 0},
-    {"FILE", COLOR_GREEN, -1, 0},
-    {"\nSIZE", COLOR_VIOLET, -1, 0},
-    {"\n\n\nBack", COLOR_WHITE, -1, 1},
-    {"\nCopy to clipboard", COLOR_BLUE, COPY, 1},
-    {"Move to clipboard", COLOR_BLUE, MOVE, 1},
-    {"\nDelete file\n", COLOR_RED, DELETE, 1},
-    {"Launch Payload", COLOR_ORANGE, PAYLOAD, 1},
-    {"View Hex", COLOR_GREEN, HEXVIEW, 1}
-};
-
-void writecurpath(const char *in){
-    if (currentpath != NULL)
-        free(currentpath);
-
-    size_t len = strlen(in) + 1;
-    currentpath = (char*) malloc (len);
-    strcpy(currentpath, in);
-
-   strcpy(currentpath, in);
-}
-
-void writeclipboard(const char *in, bool move, bool folder){
-    if (clipboard != NULL)
-        free(clipboard);
-
-    clipboardhelper = 0;
-    
-    if (move)
-        clipboardhelper |= (OPERATIONMOVE);
-    else
-        clipboardhelper |= (OPERATIONCOPY);
-
-    if (folder)
-        clipboardhelper |= (ISDIR);
-
-    size_t len = strlen(in) + 1;
-    clipboard = (char*) malloc (len);
-    strcpy(clipboard, in);
-    
-   strcpy(clipboard, in);
-}
-
-char *getnextloc(char *current, char *add){
-    char *ret;
-    size_t size = strlen(current) + strlen(add) + 1;
-    ret = (char*) malloc (size);
-    if (!strcmp(rootpath, current))
-        sprintf(ret, "%s%s", current, add);
-    else
-        sprintf(ret, "%s/%s", current, add);
-
-    return ret;
-}
-
-char *getprevloc(char *current){
-    char *ret, *temp;
-    size_t size = strlen(current) + 1;
-
-    ret = (char*) malloc (size);
-    strcpy(ret, current);
-
-    temp = strrchr(ret, '/');
-    memset(temp, '\0', 1);
-
-    if (strlen(rootpath) > strlen(ret))
-        strcpy(ret, rootpath);
-
-    return ret;
-}
-
-fs_entry getfileobj(int spot){
-    return fileobjects[spot];
-}
-
-bool checkfile(char* path){
-    FRESULT fr;
-    FILINFO fno;
-
-    fr = f_stat(path, &fno);
-
-    if (fr & FR_NO_FILE)
-        return false;
-    else
-        return true;
-}
-
-void viewbytes(char *path){
-    FIL in;
-    u8 print[2048];
-    u32 size;
-    QWORD offset = 0;
-    int res;
-
-    clearscreen();
-    res = f_open(&in, path, FA_READ | FA_OPEN_EXISTING);
-    if (res != FR_OK){
-        message("File Opening Failed", COLOR_RED);
-        return;
-    }
-
-    msleep(200);
-
-    while (1){
-        f_lseek(&in, offset * 16);
-
-        res = f_read(&in, &print, 2048 * sizeof(u8), &size);
-        if (res != FR_OK){
-            message("Reading Failed", COLOR_RED);
-            return;
-        }
-
-        printbytes(print, size, offset * 16);
-        res = btn_read();
-
-        if (!res)
-            res = btn_wait();
-
-        if (res & BTN_VOL_DOWN && 2048 * sizeof(u8) == size)
-            offset++;
-        if (res & BTN_VOL_UP && offset > 0)
-            offset--;
-        if (res & BTN_POWER)
-            break;
-    }
-    f_close(&in);
-}
-
-int copy(const char *locin, const char *locout, bool print){
-    FIL in, out;
-    u64 sizeoffile, sizecopied = 0, totalsize;
-    UINT temp1, temp2;
-    u8 *buff;
-    unsigned int x, y, i = 0;
-
-    gfx_con_getpos(&x, &y);
-
-    if (!strcmp(locin, locout)){
-        return 3;
-    }
-
-    if (f_open(&in, locin, FA_READ | FA_OPEN_EXISTING)){
-        return 1;
-    }
-
-    if (f_open(&out, locout, FA_CREATE_ALWAYS | FA_WRITE)){
-        return 2;
-    }
-
-    buff = malloc (BUFSIZE);
-    sizeoffile = f_size(&in);
-    totalsize = sizeoffile;
-
-    while (sizeoffile > 0){
-        if (f_read(&in, buff, (sizeoffile > BUFSIZE) ? BUFSIZE : sizeoffile, &temp1))
-            return 3;
-        if (f_write(&out, buff, (sizeoffile > BUFSIZE) ? BUFSIZE : sizeoffile, &temp2))
-            return 4;
-
-        if (temp1 != temp2)
-            return 5;
-
-        sizeoffile -= temp1;
-        sizecopied += temp1;
-
-        if (print && 10 > i++){
-            gfx_printf("%k[%d%%/100%%]%k", COLOR_GREEN, ((sizecopied * 100) / totalsize) ,COLOR_WHITE);
-            gfx_con_setpos(x, y);
-
-            i = 0;
-
-            if (btn_read() & BTN_VOL_DOWN){
-                f_unlink(locout);
-                break;
-            }
-        }
-    }
-
-    f_close(&in);
-    f_close(&out);
-    free(buff);
-
-    return 0;
-}
-
-void copyfile(const char *path, const char *outfolder){
-    char *filename = strrchr(path, '/');
-    char *outstring;
-    size_t outstringsize = strlen(filename) + strlen(outfolder) + 2;
-    int res;
-
-    clearscreen();
-
-    outstring = (char*) malloc (outstringsize);
-
-    if (strcmp(rootpath, outfolder))
-        sprintf(outstring, "%s/%s", outfolder, filename + 1);
-    else
-        sprintf(outstring, "%s%s", outfolder, filename + 1);
-
-    gfx_printf("Note:\nTo stop the transfer hold Vol-\n\n%s\nProgress: ", outstring);
-
-    if (clipboardhelper & OPERATIONMOVE){
-        if (strcmp(rootpath, "emmc:/"))
-            f_rename(path, outstring);
-        else
-            message("\nMoving in emummc is not allowed!", COLOR_RED);
-    }
-    
-    else if (clipboardhelper & OPERATIONCOPY) {
-        res = copy(path, outstring, true);
-        if (res){
-            gfx_printf("\n\n%kSomething went wrong while copying!\n\nErrcode: %d%k", COLOR_RED, res, COLOR_WHITE);
-            btn_wait();
-        }
-    }
-
-    else {
-        message("\nClipboard is empty!", COLOR_RED);
-    }
-
-    free (outstring);
-    clipboardhelper = 0;
-}
-
-u64 getfilesize(char *path){
-    FILINFO fno;
-    f_stat(path, &fno);
-    return fno.fsize;
-}
-
-void addobject(char* name, int spot, bool isfol, bool isarc){
-    size_t length = strlen(name) + 1;
-    u64 size = 0;
-    int sizes = 0;
-    fileobjects[spot].property = 0;
-
-    if (fileobjects[spot].name != NULL){
-        free(fileobjects[spot].name);
-        fileobjects[spot].name = NULL;
-    }
-
-    fileobjects[spot].name = (char*) malloc (length);
-    strlcpy(fileobjects[spot].name, name, length);
-
-    if (isfol)
-        fileobjects[spot].property |= (ISDIR);
-    else {
-        size = getfilesize(getnextloc(currentpath, name));
-        
-        while (size > 1024){
-            size /= 1024;
-            sizes++;
-        }
-
-        if (sizes > 3)
-            sizes = 0;
-
-        fileobjects[spot].property |= (1 << (4 + sizes));
-        fileobjects[spot].size = size;
-    }
-
-    if (isarc)
-        fileobjects[spot].property |= (ISARC);
-}
-
-int readfolder(const char *path){
-    DIR dir;
-    FILINFO fno;
-    int folderamount = 0, res;
-    
-    if (res = f_opendir(&dir, path)){
-        char errmes[50] = "";
-        sprintf(errmes, "Error during f_opendir: %d", res);
-        message(errmes, COLOR_RED);
-    }
-
-    while (!f_readdir(&dir, &fno) && fno.fname[0] && folderamount < 500){
-        addobject(fno.fname, folderamount++, (fno.fattrib & AM_DIR), (fno.fattrib & AM_ARC));
-    }
-
-    f_closedir(&dir);
-    return folderamount;
-}
-
-int delfile(const char *path, const char *filename){
-    char *tempmessage;
-    size_t tempmessagesize = strlen(filename) + 65;
-    tempmessage = (char*) malloc (tempmessagesize);
-
-    sprintf(tempmessage, "Are you sure you want to delete:\n%s\n\nPress vol+/- to cancel\n", filename);
-    if (makewaitmenu(tempmessage, "Press power to delete", 3)){
-        f_unlink(path);
-        return readfolder(currentpath);
-    }
-    else
-        return -1;
-}
-
-void filemenu(const char *startpath){
-    int amount, res, tempint;
-    char temp[100];
-
-    if (!strcmp(rootpath, "emmc:/") && !strcmp(startpath, "emmc:/"))
-        clipboardhelper = 0;
-
-    strcpy(rootpath, startpath);
-    writecurpath(startpath);
-    amount = readfolder(currentpath);
-
-    if (strcmp(rootpath, "emmc:/"))
-        explfilemenu[5].property = 1;
-    else
-        explfilemenu[5].property = -1;
-
-    while (1){
-        res = makefilemenu(fileobjects, amount, currentpath);
-        if (res < 1){
-            if (res == -2){
-                if (!strcmp(rootpath, currentpath))
-                    break;
-                else {
-                    writecurpath(getprevloc(currentpath));
-                    amount = readfolder(currentpath);
-                }
-            }
-            if (res == -1){
-                copyfile(clipboard, currentpath);
-                amount = readfolder(currentpath);
-            }
-                
-            if (res == 0)
-                break;
-        }
-        else {
-            if (fileobjects[res - 1].property & ISDIR){
-                writecurpath(getnextloc(currentpath, fileobjects[res - 1].name));
-                amount = readfolder(currentpath);
-            }
-            else {
-                strlcpy(explfilemenu[1].name, fileobjects[res - 1].name, 43);
-            
-                for (tempint = 4; tempint < 8; tempint++)
-                    if ((fileobjects[res - 1].property & (1 << tempint)))
-                        break;
-
-                sprintf(temp, "\nSize: %d %s", fileobjects[res - 1].size, sizevalues[tempint - 4]);
-                strcpy(explfilemenu[2].name, temp);
-
-                if (strstr(fileobjects[res - 1].name, ".bin") != NULL && fileobjects[res - 1].size & ISKB){
-                    explfilemenu[7].property = 1;
-                }
-                else
-                    explfilemenu[7].property = -1;
-
-                tempint = makemenu(explfilemenu, 9);
-
-                switch (tempint){
-                    case COPY:
-                        writeclipboard(getnextloc(currentpath, fileobjects[res - 1].name), false, false);
-                        break;
-                    case MOVE:
-                        writeclipboard(getnextloc(currentpath, fileobjects[res - 1].name), true, false);
-                        break;
-                    case DELETE:
-                        if ((tempint = delfile(getnextloc(currentpath, fileobjects[res - 1].name), fileobjects[res - 1].name)) != -1)
-                                amount = tempint;
-                        break;
-                    case PAYLOAD:
-                        launch_payload(getnextloc(currentpath, fileobjects[res - 1].name));
-                        break;
-                    case HEXVIEW:
-                        viewbytes(getnextloc(currentpath, fileobjects[res - 1].name));
-                        break;
-                }
-            }
-        }
-    }
-}
--- a/source/tegraexplorer/fs.h
+++ b/source/tegraexplorer/fs.h
@@ -1,44 +0,0 @@
-#pragma once
-#include "../utils/types.h"
-
-#define ISDIR (1 << 0)
-#define ISARC (1 << 1)
-
-#define ISGB (1 << 7)
-#define ISMB (1 << 6)
-#define ISKB (1 << 5)
-#define ISB  (1 << 4)
-
-#define OPERATIONCOPY (1 << 1)
-#define OPERATIONMOVE (1 << 2)
-
-#define BUFSIZE 32768
-
-/* Bit table for property:
-0000 0001: Directory bit
-0000 0010: Archive bit
-0001 0000: Size component is a Byte
-0010 0000: Size component is a KiloByte
-0100 0000: Size component is a MegaByte
-1000 0000: Size component is a GigaByte : note that this won't surpass gigabytes, but i don't expect people to have a single file that's a terrabyte big
-*/
-
-typedef struct _fs_entry {
-    char* name;
-    u16 size;
-    u8 property;
-} fs_entry;
-
-enum filemenuoptions {
-    COPY = 1,
-    MOVE,
-    DELETE,
-    PAYLOAD,
-    HEXVIEW
-};
-
-int readfolder(const char *path);
-void filemenu();
-bool checkfile(char* path);
-u64 getfilesize(char *path);
-int copy(const char *locin, const char *locout, bool print);
--- a/source/tegraexplorer/fs/entrymenu.h
+++ b/source/tegraexplorer/fs/entrymenu.h
@@ -0,0 +1,7 @@
+#pragma once
+#include "../common/types.h"
+
+int filemenu(menu_entry file);
+void copyfile(const char *src_in, const char *outfolder);
+int foldermenu();
+void copyfolder(char *in, char *out);
--- a/source/tegraexplorer/fs/filemenu.c
+++ b/source/tegraexplorer/fs/filemenu.c
@@ -0,0 +1,185 @@
+#include <string.h>
+#include "entrymenu.h"
+#include "../common/common.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/btn.h"
+#include "../../gfx/gfx.h"
+#include "fsutils.h"
+#include "fsactions.h"
+#include "../utils/utils.h"
+#include "../gfx/gfxutils.h"
+#include "../../mem/heap.h"
+#include "fsreader.h"
+#include "../gfx/menu.h"
+#include "../common/types.h"
+#include "../../utils/sprintf.h"
+#include "../utils/script.h"
+#include "../emmc/emmcoperations.h"
+
+extern char *currentpath;
+extern char *clipboard;
+extern u8 clipboardhelper;
+extern int launch_payload(char *path);
+
+int delfile(const char *path, const char *filename){
+    gfx_clearscreen();
+    SWAPCOLOR(COLOR_ORANGE);
+    gfx_printf("Are you sure you want to delete:\n%s\n\nPress vol+/- to cancel\n", filename);
+    if (gfx_makewaitmenu("Press power to delete", 3)){
+        f_unlink(path);
+        fsreader_readfolder(currentpath);
+        return 0;
+    }
+    else
+        return -1;
+}
+
+void viewbytes(char *path){
+    FIL in;
+    u8 print[2048];
+    u32 size;
+    QWORD offset = 0;
+    int res;
+
+    gfx_clearscreen();
+    if ((res = f_open(&in, path, FA_READ | FA_OPEN_EXISTING))){
+        gfx_errDisplay("viewbytes", res, 1);
+        return;
+    }
+
+    msleep(200);
+
+    while (1){
+        f_lseek(&in, offset * 16);
+
+        if ((res = f_read(&in, &print, 2048 * sizeof(u8), &size))){
+            gfx_errDisplay("viewbytes", res, 2);
+            return;
+        }
+
+        gfx_con_setpos(0, 31);
+        gfx_hexdump(offset * 16, print, size * sizeof(u8));
+
+        res = btn_read();
+
+        if (!res)
+            res = btn_wait();
+
+        if (res & BTN_VOL_DOWN && 2048 * sizeof(u8) == size)
+            offset++;
+        if (res & BTN_VOL_UP && offset > 0)
+            offset--;
+        if (res & BTN_POWER)
+            break;
+    }
+    f_close(&in);
+}
+
+void copyfile(const char *src_in, const char *outfolder){
+    char *in, *out, *filename;
+    int res;
+
+    gfx_clearscreen();
+    utils_copystring(src_in, &in);
+    utils_copystring(strrchr(in, '/') + 1, &filename);
+    utils_copystring(fsutil_getnextloc(outfolder, filename), &out);
+
+    gfx_printf("Note:\nTo stop the transfer hold Vol-\n\n%s\nProgress: ", filename);
+
+    if (!strcmp(in, out)){
+        gfx_errDisplay("gfxcopy", ERR_SAME_LOC, 1);
+        return;
+    }
+
+    if (clipboardhelper & OPERATIONMOVE){
+        if ((res = f_rename(in, out))){
+            gfx_errDisplay("gfxcopy", res, 2);
+            return;
+        }
+    }
+    else if (clipboardhelper & OPERATIONCOPY) {
+        if (fsact_copy(in, out, COPY_MODE_CANCEL | COPY_MODE_PRINT))
+            return;
+    }
+
+    else {
+        gfx_errDisplay("gfxcopy", ERR_EMPTY_CLIPBOARD, 3);
+        return;
+    }
+
+    free(in);
+    free(out);
+    free(filename);
+    fsreader_readfolder(currentpath);
+    clipboardhelper = 0;
+}
+
+int filemenu(menu_entry file){
+    int temp;
+    FILINFO attribs;
+
+    for (int i = 0; i < 3; i++)
+        if (fs_menu_file[i].name != NULL)
+            free(fs_menu_file[i].name);
+    
+    utils_copystring(file.name, &fs_menu_file[0].name);
+    fs_menu_file[1].name = malloc(16);
+    fs_menu_file[2].name = malloc(16);
+            
+    for (temp = 4; temp < 8; temp++)
+        if ((file.property & (1 << temp)))
+            break;
+
+    
+    sprintf(fs_menu_file[1].name, "\nSize: %d %s", file.storage, gfx_file_size_names[temp - 4]);
+
+    if (f_stat(fsutil_getnextloc(currentpath, file.name), &attribs))
+        SETBIT(fs_menu_file[2].property, ISHIDE, 1);
+    else {
+        SETBIT(fs_menu_file[2].property, ISHIDE, 0);
+        sprintf(fs_menu_file[2].name, "Attribs: %c%c%c%c",
+        (attribs.fattrib & AM_RDO) ? 'R' : '-',
+        (attribs.fattrib & AM_SYS) ? 'S' : '-',
+        (attribs.fattrib & AM_HID) ? 'H' : '-',
+        (attribs.fattrib & AM_ARC) ? 'A' : '-');
+    }
+
+    SETBIT(fs_menu_file[7].property, ISHIDE, !(strstr(file.name, ".bin") != NULL && file.property & ISKB));
+    SETBIT(fs_menu_file[8].property, ISHIDE, !(strstr(file.name, ".tegrascript") != NULL));
+    SETBIT(fs_menu_file[10].property, ISHIDE, !(strstr(file.name, ".bis") != NULL));
+    SETBIT(fs_menu_file[11].property, ISHIDE, !(strstr(file.name, ".bis") != NULL));
+
+    temp = menu_make(fs_menu_file, 12, "-- File Menu --");
+
+    switch (temp){
+        case FILE_COPY:
+            fsreader_writeclipboard(fsutil_getnextloc(currentpath, file.name), OPERATIONCOPY);
+            break;
+        case FILE_MOVE:
+            fsreader_writeclipboard(fsutil_getnextloc(currentpath, file.name), OPERATIONMOVE);
+            break;
+        case FILE_DELETE:
+            delfile(fsutil_getnextloc(currentpath, file.name), file.name);
+            break;
+        case FILE_PAYLOAD:
+            launch_payload(fsutil_getnextloc(currentpath, file.name));
+            break;
+        case FILE_SCRIPT:
+            ParseScript(fsutil_getnextloc(currentpath, file.name));
+            break;
+        case FILE_HEXVIEW:
+            viewbytes(fsutil_getnextloc(currentpath, file.name));
+            break;
+        case FILE_DUMPBIS:
+            gfx_clearscreen();
+            extract_bis_file(fsutil_getnextloc(currentpath, file.name), currentpath);
+            fsreader_readfolder(currentpath);
+            btn_wait();
+            break;
+        case FILE_RESTOREBIS:
+            restore_bis_using_file(fsutil_getnextloc(currentpath, file.name), SYSMMC);
+            break;
+    }
+
+    return 0;
+}
--- a/source/tegraexplorer/fs/foldermenu.c
+++ b/source/tegraexplorer/fs/foldermenu.c
@@ -0,0 +1,89 @@
+#include <string.h>
+#include "entrymenu.h"
+#include "../common/common.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../mem/heap.h"
+#include "../gfx/menu.h"
+#include "fsreader.h"
+#include "../gfx/gfxutils.h"
+#include "fsactions.h"
+#include "fsutils.h"
+#include "../../utils/sprintf.h"
+
+extern char *currentpath;
+extern char *clipboard;
+extern u8 clipboardhelper;
+
+void copyfolder(char *in, char *out){
+    int res;
+
+    res = strlen(in);
+    if ((*(in + res - 1) == '/')){
+        gfx_errDisplay("copyfolder", ERR_FOLDER_ROOT, 1);
+    }
+    else if (strstr(out, in) != NULL){
+        gfx_errDisplay("copyfolder", ERR_DEST_PART_OF_SRC, 2);
+    }
+    else if (!strcmp(in, out)){
+        gfx_errDisplay("copyfolder", ERR_SAME_LOC, 3);
+    }
+    else {
+        gfx_clearscreen();
+        gfx_printf("\nCopying folder, please wait\n");
+        fsact_copy_recursive(in, out);
+        fsreader_readfolder(currentpath);
+    }
+
+    clipboardhelper = 0;
+}
+
+int foldermenu(){
+    int res;
+    FILINFO attribs;
+
+    if (fs_menu_folder[0].name != NULL)
+        free(fs_menu_folder[0].name);
+
+    fs_menu_folder[0].name = malloc(16);
+
+    res = strlen(currentpath);
+
+    SETBIT(fs_menu_folder[3].property, ISHIDE, (*(currentpath + res - 1) == '/'));
+    SETBIT(fs_menu_folder[4].property, ISHIDE, (*(currentpath + res - 1) == '/'));
+  
+    if (f_stat(currentpath, &attribs))
+        SETBIT(fs_menu_folder[0].property, ISHIDE, 1);
+    else {
+        SETBIT(fs_menu_folder[0].property, ISHIDE, 0);
+        sprintf(fs_menu_folder[0].name, "Attribs: %c%c%c%c",
+        (attribs.fattrib & AM_RDO) ? 'R' : '-',
+        (attribs.fattrib & AM_SYS) ? 'S' : '-',
+        (attribs.fattrib & AM_HID) ? 'H' : '-',
+        (attribs.fattrib & AM_ARC) ? 'A' : '-');
+    }
+
+    res = menu_make(fs_menu_folder, 5, currentpath);
+
+    switch (res){
+        case DIR_EXITFOLDER:
+            return -1;
+        case DIR_COPYFOLDER:
+            fsreader_writeclipboard(currentpath, OPERATIONCOPY | ISDIR);
+            break;
+        case DIR_DELETEFOLDER:
+            gfx_clearscreen();
+            gfx_printf("Do you want to delete this folder?\nThe entire folder, with all subcontents\n     will be deleted!!!\n\nPress vol+/- to cancel\n");
+            if (gfx_makewaitmenu("Press power to contine...", 3)){
+                gfx_clearscreen();
+                gfx_printf("\nDeleting folder, please wait...\n");
+
+                fsact_del_recursive(currentpath);
+
+                fsreader_writecurpath(fsutil_getprevloc(currentpath));
+                fsreader_readfolder(currentpath);
+            }
+            break;
+    }
+
+    return 0;
+}
--- a/source/tegraexplorer/fs/fsactions.c
+++ b/source/tegraexplorer/fs/fsactions.c
@@ -0,0 +1,193 @@
+#include <string.h>
+
+#include "fsactions.h"
+#include "../common/common.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../gfx/gfx.h"
+#include "../gfx/gfxutils.h"
+#include "../utils/utils.h"
+#include "../../mem/heap.h"
+#include "../../utils/btn.h"
+#include "fsutils.h"
+
+int fsact_copy(const char *locin, const char *locout, u8 options){
+    FIL in, out;
+    FILINFO in_info;
+    u64 sizeoffile, sizecopied = 0, totalsize;
+    UINT temp1, temp2;
+    u8 *buff;
+    unsigned int x, y, i = 0;
+    int res;
+
+    gfx_con_getpos(&x, &y);
+
+    if (!strcmp(locin, locout)){
+        gfx_errDisplay("copy", ERR_SAME_LOC, 1);
+        return -1;
+    }
+
+    if ((res = f_open(&in, locin, FA_READ | FA_OPEN_EXISTING))){
+        gfx_errDisplay("copy", res, 2);
+        return -1;
+    }
+
+    if (f_stat(locin, &in_info)){
+        gfx_errDisplay("copy", res, 3);
+        return -1;
+    }
+       
+    if (f_open(&out, locout, FA_CREATE_ALWAYS | FA_WRITE)){
+        gfx_errDisplay("copy", res, 4);
+        return -1;
+    }
+
+    buff = malloc (BUFSIZE);
+    sizeoffile = f_size(&in);
+    totalsize = sizeoffile;
+
+    while (sizeoffile > 0){
+        if ((res = f_read(&in, buff, (sizeoffile > BUFSIZE) ? BUFSIZE : sizeoffile, &temp1))){
+            gfx_errDisplay("copy", res, 5);
+            return -1;
+        }
+            
+        if ((res = f_write(&out, buff, (sizeoffile > BUFSIZE) ? BUFSIZE : sizeoffile, &temp2))){
+            gfx_errDisplay("copy", res, 6);
+            return -1;
+        }
+            
+        if (temp1 != temp2){
+            gfx_errDisplay("copy", ERR_DISK_WRITE_FAILED, 7);
+            return -1;
+        }
+
+        sizeoffile -= temp1;
+        sizecopied += temp1;
+
+        if (options & COPY_MODE_PRINT && 10 > i++){
+            gfx_printf("%k[%d%%]%k", COLOR_GREEN, ((sizecopied * 100) / totalsize) ,COLOR_WHITE);
+            gfx_con_setpos(x, y);
+            
+            i = 0;
+
+            if (options & COPY_MODE_CANCEL)
+                if (btn_read() & BTN_VOL_DOWN){
+                    f_unlink(locout);
+                    break;
+                }
+        }
+    }
+
+    f_close(&in);
+    f_close(&out);
+    free(buff);
+
+    if ((res = f_chmod(locout, in_info.fattrib, 0x3A))){
+        gfx_errDisplay("copy", res, 8);
+        return -1;
+    }
+
+    f_stat(locin, &in_info); //somehow stops fatfs from being weird
+    return 0;
+}
+
+int fsact_del_recursive(char *path){
+    DIR dir;
+    FILINFO fno;
+    int res;
+    u32 x, y;
+    char *localpath = NULL;
+
+    gfx_con_getpos(&x, &y);
+    utils_copystring(path, &localpath);
+
+    if ((res = f_opendir(&dir, localpath))){
+        gfx_errDisplay("del_recursive", res, 1);
+        return -1;
+    }
+
+    while (!f_readdir(&dir, &fno) && fno.fname[0]){
+        if (fno.fattrib & AM_DIR){
+            fsact_del_recursive(fsutil_getnextloc(localpath, fno.fname));
+        }
+        else {
+            SWAPCOLOR(COLOR_RED);
+            gfx_printf("\r");
+            gfx_printandclear(fno.fname, 37);
+
+            if ((res = f_unlink(fsutil_getnextloc(localpath, fno.fname)))){
+                gfx_errDisplay("del_recursive", res, 2);
+                return -1;
+            }        
+        }
+    }
+
+    f_closedir(&dir);
+
+    if ((res = f_unlink(localpath))){
+        gfx_errDisplay("del_recursive", res, 3);
+        return -1;
+    }
+
+    free(localpath);
+    return 0;
+}
+
+int fsact_copy_recursive(char *path, char *dstpath){
+    DIR dir;
+    FILINFO fno;
+    int res;
+    u32 x, y;
+    char *startpath = NULL, *destpath = NULL, *destfoldername = NULL, *temp = NULL;
+
+    gfx_con_getpos(&x, &y);
+
+    utils_copystring(path, &startpath);
+    utils_copystring(strrchr(path, '/') + 1, &destfoldername);
+    utils_copystring(fsutil_getnextloc(dstpath, destfoldername), &destpath);
+
+    if ((res = f_opendir(&dir, startpath))){
+        gfx_errDisplay("copy_recursive", res, 1);
+        return -1;
+    }
+
+    f_mkdir(destpath);
+
+    while (!f_readdir(&dir, &fno) && fno.fname[0]){
+        if (fno.fattrib & AM_DIR){
+            fsact_copy_recursive(fsutil_getnextloc(startpath, fno.fname), destpath);
+        }
+        else {
+            SWAPCOLOR(COLOR_GREEN);
+            gfx_printf("\r");
+            gfx_printandclear(fno.fname, 37);
+
+            utils_copystring(fsutil_getnextloc(startpath, fno.fname), &temp);
+
+            if ((res = fsact_copy(temp, fsutil_getnextloc(destpath, fno.fname), COPY_MODE_PRINT))){
+                gfx_errDisplay("copy_recursive", res, 2);
+                return -1;
+            }
+
+            free(temp);
+        }
+    }
+    
+    f_closedir(&dir);
+    
+    if ((res = (f_stat(startpath, &fno)))){
+        gfx_errDisplay("copy_recursive", res, 3);
+        return -1;
+    }
+
+    if ((res = f_chmod(destpath, fno.fattrib, 0x3A))){
+        gfx_errDisplay("copy_recursive", res, 4);
+        return -1;
+    }
+    
+    free(startpath);
+    free(destpath);
+    free(destfoldername);
+
+    return 0;
+}
--- a/source/tegraexplorer/fs/fsactions.h
+++ b/source/tegraexplorer/fs/fsactions.h
@@ -0,0 +1,6 @@
+#pragma once
+#include "../../utils/types.h"
+
+int fsact_copy(const char *locin, const char *locout, u8 options);
+int fsact_del_recursive(char *path);
+int fsact_copy_recursive(char *path, char *dstpath);
--- a/source/tegraexplorer/fs/fsextractbis.c
+++ b/source/tegraexplorer/fs/fsextractbis.c
@@ -0,0 +1,94 @@
+#include "fsutils.h"
+#include <string.h>
+#include "../../gfx/gfx.h"
+#include "../gfx/gfxutils.h"
+#include "../../utils/types.h"
+#include "../../storage/emummc.h"
+#include "../common/common.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/sprintf.h"
+#include "../../utils/btn.h"
+#include "../../mem/heap.h"
+#include "../../storage/nx_emmc.h"
+#include "../common/types.h"
+#include "../utils/utils.h"
+
+u32 DecodeInt(u8* data) {
+    u32 out = 0;
+
+    for (int i = 0; i < 4; i++) {
+        out |= (data[i] << ((3 - i) * 8));
+    }
+
+    return out;
+}
+
+void copy_fil_size(FIL* in_src, FIL* out_src, int size_src){
+    u8* buff;
+    buff = calloc(16384, sizeof(u8));
+
+    int size = size_src;
+    int copysize;
+
+    while (size > 0){
+        copysize = MIN(16834, size);
+        f_read(in_src, buff, copysize, NULL);
+        f_write(out_src, buff, copysize, NULL);
+        size -= copysize;
+    }
+
+    free(buff);
+}
+
+void gen_part(int size, FIL* in, char *path){
+    FIL out;
+
+    f_open(&out, path, FA_WRITE | FA_CREATE_ALWAYS);
+    copy_fil_size(in, &out, size);
+    f_close(&out);
+}
+
+int extract_bis_file(char *path, char *outfolder){
+    FIL in;
+    int res;
+    u8 version[0x10];
+    u8 args;
+    u8 temp[0x4];
+    u32 filesizes[4];
+
+    if ((res = f_open(&in, path, FA_READ | FA_OPEN_EXISTING))){
+        gfx_errDisplay("extract_bis_file", res, 0);
+        return -1;
+    }
+
+    f_read(&in, version, 0x10, NULL);
+    f_read(&in, &args, 1, NULL);
+
+    for (int i = 0; i < 4; i++){
+        f_read(&in, temp, 4, NULL);
+        filesizes[i] = DecodeInt(temp);
+    }
+
+    gfx_printf("Version: %s\n\n", version);
+
+    gfx_printf("\nExtracting BOOT0\n");
+    if (args & BOOT0_ARG)
+        gen_part(filesizes[0], &in, fsutil_getnextloc(outfolder, "BOOT0.bin"));
+
+    gfx_printf("Extracting BOOT1\n");
+    if (args & BOOT1_ARG)
+        gen_part(filesizes[1], &in, fsutil_getnextloc(outfolder, "BOOT1.bin"));
+
+    gfx_printf("Extracting BCPKG2_1\n");
+    if (args & BCPKG2_1_ARG)
+        gen_part(filesizes[2], &in, fsutil_getnextloc(outfolder, "BCPKG2-1-Normal-Main"));
+
+    gfx_printf("Extracting BCPKG2_3\n");
+    if (args & BCPKG2_3_ARG)
+        gen_part(filesizes[3], &in, fsutil_getnextloc(outfolder, "BCPKG2-3-SafeMode-Main"));
+
+    gfx_printf("\n\nDone!\n");
+
+    f_close(&in);
+    return 0;   
+}
--- a/source/tegraexplorer/fs/fsmenu.c
+++ b/source/tegraexplorer/fs/fsmenu.c
@@ -0,0 +1,115 @@
+#include <string.h>
+#include "fsmenu.h"
+#include "fsreader.h"
+#include "../gfx/menu.h"
+#include "../gfx/gfxutils.h"
+#include "fsutils.h"
+#include "../common/common.h"
+#include "../../libs/fatfs/ff.h"
+#include "entrymenu.h"
+
+extern char *currentpath;
+extern char *clipboard;
+extern u8 clipboardhelper;
+int lastentry = 0;
+
+void fileexplorer(const char *startpath, int type){
+    int res;
+    
+    if (lastentry > 0 && lastentry == type)
+        clipboardhelper = 0;
+    
+    lastentry = type;
+    
+    fsreader_writecurpath(startpath);
+    fsreader_readfolder(currentpath);
+
+    /*
+    if (strcmp(rootpath, "emmc:/"))
+        explfilemenu[6].property = 1;
+    else
+        explfilemenu[6].property = -1;
+    */
+
+    while (1){
+        res = menu_make(fsreader_files, fsutil_getfileobjamount(fsreader_files), currentpath);
+        switch (res){
+            case FILEMENU_RETURN:
+                if (!strcmp(startpath, currentpath))
+                    return;
+                else {
+                    fsreader_writecurpath(fsutil_getprevloc(currentpath));
+                    fsreader_readfolder(currentpath);
+                }
+
+                break;
+            case FILEMENU_CLIPBOARD:
+                if (clipboardhelper & ISDIR)
+                    copyfolder(clipboard, currentpath);
+                else
+                    copyfile(clipboard, currentpath);
+                break;
+            
+            case FILEMENU_CURFOLDER:
+                if (foldermenu())
+                    return;
+                break;
+
+            default:
+                if(fsreader_files[res].property & ISDIR){
+                    fsreader_writecurpath(fsutil_getnextloc(currentpath, fsreader_files[res].name));
+                    fsreader_readfolder(currentpath);
+                }
+                else
+                    filemenu(fsreader_files[res]);
+                
+                break;
+        }
+    }
+    /*
+    while (1){
+        res = makefilemenu(fileobjects, getfileobjamount(), currentpath);
+        if (res < 1){
+            switch (res){
+                case -2:
+                    if (!strcmp(rootpath, currentpath))
+                        breakfree = true;
+                    else {
+                        writecurpath(getprevloc(currentpath));
+                        readfolder(currentpath);
+                    }
+
+                    break;
+                
+                case -1:
+                    if (clipboardhelper & ISDIR)
+                        copyfolder(clipboard, currentpath);
+                    else
+                        copyfile(clipboard, currentpath);
+                    break;
+
+                case 0:
+                    tempint = foldermenu();
+
+                    if (tempint == -1)
+                        breakfree = true;
+
+                    break;
+                
+            }
+        }
+        else {
+            if (fileobjects[res - 1].property & ISDIR){
+                writecurpath(getnextloc(currentpath, fileobjects[res - 1].name));
+                readfolder(currentpath);
+            }
+            else {
+                filemenu(fileobjects[res - 1]);
+            }
+        }
+
+        if (breakfree)
+            break;
+    }
+    */
+}
--- a/source/tegraexplorer/fs/fsmenu.h
+++ b/source/tegraexplorer/fs/fsmenu.h
@@ -0,0 +1,3 @@
+#pragma once
+
+void fileexplorer(const char *startpath, int type);
--- a/source/tegraexplorer/fs/fsreader.c
+++ b/source/tegraexplorer/fs/fsreader.c
@@ -0,0 +1,106 @@
+#include "fsreader.h"
+#include "../common/types.h"
+#include "../common/common.h"
+#include "fsutils.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../gfx/gfxutils.h"
+#include "../utils/utils.h"
+#include "../../mem/heap.h"
+
+menu_entry *fsreader_files = NULL;
+char *currentpath = NULL;
+char *clipboard = NULL;
+u8 clipboardhelper = 0;
+
+void fsreader_writecurpath(const char *in){
+    if (currentpath != NULL)
+        free(currentpath);
+
+    utils_copystring(in, &currentpath);
+}
+
+void fsreader_writeclipboard(const char *in, u8 args){
+    if (clipboard != NULL)
+        free(clipboard);
+
+    clipboardhelper = args;
+
+    utils_copystring(in, &clipboard);
+}
+
+void clearfileobjects(){
+    if (fsreader_files != NULL){
+        for (int i = 0; fsreader_files[i].name != NULL; i++){
+            free(fsreader_files[i].name);
+            fsreader_files[i].name = NULL;
+        }
+        free(fsreader_files);
+        fsreader_files = NULL;
+    }
+}
+
+void createfileobjects(int size){
+    fsreader_files = calloc (size + 1, sizeof(menu_entry));
+    fsreader_files[size].name = NULL;
+}
+
+void addobject(char* name, int spot, u8 attribs){
+    u64 size = 0;
+    int sizes = 0;
+    fsreader_files[spot].property = 0;
+
+    if (fsreader_files[spot].name != NULL){
+        free(fsreader_files[spot].name);
+        fsreader_files[spot].name = NULL;
+    }
+
+    utils_copystring(name, &(fsreader_files[spot].name));
+
+    if (attribs & AM_DIR)
+        fsreader_files[spot].property |= (ISDIR);
+    else {
+        size = fsutil_getfilesize(fsutil_getnextloc(currentpath, name));
+        
+        while (size > 1024){
+            size /= 1024;
+            sizes++;
+        }
+
+        if (sizes > 3)
+            sizes = 0;
+
+        fsreader_files[spot].property |= (1 << (4 + sizes));
+        fsreader_files[spot].storage = size;
+    }
+
+    if (attribs & AM_ARC)
+        fsreader_files[spot].property |= (ISARC);
+}
+
+int fsreader_readfolder(const char *path){
+    DIR dir;
+    FILINFO fno;
+    int folderamount, res;
+    
+    clearfileobjects();
+    createfileobjects(fsutil_getfolderentryamount(path) + 3);
+
+    for (folderamount = 0; folderamount < 3; folderamount++){
+        utils_copystring(fs_menu_startdir[folderamount].name, &(fsreader_files[folderamount].name));
+        fsreader_files[folderamount].storage = fs_menu_startdir[folderamount].storage;
+        fsreader_files[folderamount].property = fs_menu_startdir[folderamount].property;
+    }
+
+    if ((res = f_opendir(&dir, path))){
+        gfx_errDisplay("readfolder", res, 0);
+        return -1;
+    }
+
+    while (!f_readdir(&dir, &fno) && fno.fname[0]){
+        addobject(fno.fname, folderamount++, fno.fattrib);
+    }
+
+    f_closedir(&dir);
+    return folderamount;
+}
--- a/source/tegraexplorer/fs/fsreader.h
+++ b/source/tegraexplorer/fs/fsreader.h
@@ -0,0 +1,7 @@
+#pragma once
+#include "../common/types.h"
+
+extern menu_entry *fsreader_files;
+void fsreader_writecurpath(const char *in);
+void fsreader_writeclipboard(const char *in, u8 args);
+int fsreader_readfolder(const char *path);
--- a/source/tegraexplorer/fs/fsutils.c
+++ b/source/tegraexplorer/fs/fsutils.c
@@ -0,0 +1,90 @@
+#include <string.h>
+#include "fsutils.h"
+#include "../utils/utils.h"
+#include "../common/types.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../mem/heap.h"
+#include "../../utils/sprintf.h"
+#include "../gfx/gfxutils.h"
+
+char *fsutil_getnextloc(const char *current, const char *add){
+    static char *ret;
+
+    if (ret != NULL){
+        free(ret);
+        ret = NULL;
+    }
+
+    size_t size = strlen(current) + strlen(add) + 2;
+    ret = (char*) malloc (size);
+
+    if (current[strlen(current) - 1] == '/')
+        sprintf(ret, "%s%s", current, add);
+    else
+        sprintf(ret, "%s/%s", current, add);
+
+    return ret;
+}
+
+char *fsutil_getprevloc(char *current){
+    static char *ret;
+    char *temp;
+
+    if (ret != NULL){
+        free(ret);
+        ret = NULL;
+    }
+
+    utils_copystring(current, &ret);
+    temp = strrchr(ret, '/');
+
+    if (*(temp - 1) == ':')
+        temp++;
+
+    *temp = '\0';
+
+    return ret;
+}
+
+int fsutil_getfileobjamount(menu_entry *entries){
+    int amount = 0;
+
+    while (entries[amount].name != NULL)
+        amount++;
+
+    return amount;
+}
+
+bool fsutil_checkfile(char* path){
+    FRESULT fr;
+    FILINFO fno;
+
+    fr = f_stat(path, &fno);
+
+    return !(fr & FR_NO_FILE);
+}
+
+u64 fsutil_getfilesize(char *path){
+    FILINFO fno;
+    f_stat(path, &fno);
+    return fno.fsize;
+}
+
+int fsutil_getfolderentryamount(const char *path){
+    DIR dir;
+    FILINFO fno;
+    int folderamount = 0, res;
+
+    if ((res = f_opendir(&dir, path))){
+        gfx_errDisplay("fsutil_getdircount", res, 0);
+        return -1;
+    }
+
+    while (!f_readdir(&dir, &fno) && fno.fname[0]){
+        folderamount++;
+    }
+
+    f_closedir(&dir);
+    return folderamount;
+}
--- a/source/tegraexplorer/fs/fsutils.h
+++ b/source/tegraexplorer/fs/fsutils.h
@@ -0,0 +1,11 @@
+#pragma once
+#include "../common/types.h"
+#include "../../utils/types.h"
+
+char *fsutil_getnextloc(const char *current, const char *add);
+char *fsutil_getprevloc(char *current);
+int fsutil_getfileobjamount(menu_entry *entries);
+bool fsutil_checkfile(char* path);
+u64 fsutil_getfilesize(char *path);
+int fsutil_getfolderentryamount(const char *path);
+int extract_bis_file(char *path, char *outfolder);
--- a/source/tegraexplorer/gfx.c
+++ b/source/tegraexplorer/gfx.c
@@ -1,214 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "../gfx/gfx.h"
-#include "te.h"
-#include "../utils/btn.h"
-#include "../utils/util.h"
-#include "gfx.h"
-#include "fs.h"
-#include "../mem/minerva.h"
-
-const char fixedoptions[3][50] = {
-    "Folder -> previous folder                  ",
-    "Clipboard -> Current folder                ",
-    "Return to main menu                        "
-};
-
-const char sizevalues[4][3] = {
-    "B ",
-    "KB",
-    "MB",
-    "GB"
-};
-
-void clearscreen(){
-    gfx_clear_grey(0x1B);
-    gfx_box(0, 0, 719, 15, COLOR_WHITE);
-    gfx_con_setpos(0, 0);
-    gfx_printf("%k%KTegraexplorer v1.1.0%k%K\n", COLOR_DEFAULT, COLOR_WHITE, COLOR_WHITE, COLOR_DEFAULT);
-}
-
-int message(char* message, u32 color){
-    clearscreen();
-    gfx_printf("%k%s%k", color, message, COLOR_DEFAULT);
-    return btn_wait();
-}
-
-int makemenu(menu_item menu[], int menuamount){
-    int currentpos = 1, i, res;
-    clearscreen();
-
-    while (1){
-        gfx_con_setpos(0, 31);
-
-        if (currentpos == 1){
-            while (currentpos < menuamount && menu[currentpos - 1].property < 1)
-                currentpos++;
-        }
-        if (currentpos == menuamount){
-            while (currentpos > 1 && menu[currentpos - 1].property < 1)
-                currentpos--;
-        }
-
-        for (i = 0; i < menuamount; i++){
-            if (menu[i].property < 0)
-                continue;
-            if (i == currentpos - 1)
-                gfx_printf("%k%K%s%K\n", COLOR_DEFAULT, COLOR_WHITE, menu[i].name, COLOR_DEFAULT);
-            else
-                gfx_printf("%k%s\n", menu[i].color, menu[i].name);
-        }
-        gfx_printf("\n%k%s", COLOR_WHITE, menuamount);
-
-        res = btn_wait();
-
-        if (res & BTN_VOL_UP && currentpos > 1){
-            currentpos--;
-            while(menu[currentpos - 1].property < 1 && currentpos > 1)
-                currentpos--;
-        }
-            
-        else if (res & BTN_VOL_DOWN && currentpos < menuamount){
-            currentpos++;
-            while(menu[currentpos - 1].property < 1 && currentpos < menuamount)
-                currentpos++;
-        }
-
-        else if (res & BTN_POWER)
-            return menu[currentpos - 1].internal_function;
-    }
-}
-
-void printbytes(u8 print[], u32 size, u32 offset){
-    gfx_con_setpos(0, 31);
-    gfx_hexdump(offset, print, size * sizeof(u8));
-}
-
-int makewaitmenu(char *initialmessage, char *hiddenmessage, int timer){
-    clearscreen();
-    int res;
-    u32 start = get_tmr_s();
-
-    gfx_printf(initialmessage);
-
-    while(1){
-        res = btn_read();
-
-        if (res & BTN_VOL_DOWN || res & BTN_VOL_UP)
-            return 0;
-
-        if (start + timer > get_tmr_s())
-            gfx_printf("\r<Wait %d seconds> ", timer + start - get_tmr_s());
-
-        else if (res & BTN_POWER)
-            return 1;
-
-        else 
-            gfx_printf("\r%k%s%k", COLOR_RED, hiddenmessage, COLOR_WHITE);
-    }
-}
-
-void printfsentry(fs_entry file, bool highlight, bool refresh){
-    int size = 0;
-    char *display;
-    int length;
-
-    display = (char*) malloc (38);
-    memset(display + 37, '\0', 1);
-    
-    if (strlen(file.name) > 37){
-        strlcpy(display, file.name, 37);
-        memset(display + 34, '.', 3);
-    }
-    else
-        strcpy(display, file.name);
-
-    if (highlight)
-        gfx_printf("%K%k", COLOR_WHITE, COLOR_DEFAULT);
-    else
-        RESETCOLOR;
-
-    if (file.property & ISDIR)
-        gfx_printf("%s", display);
-    else {
-        for (size = 4; size < 8; size++)
-            if ((file.property & (1 << size)))
-                break;
-
-        SWAPCOLOR(COLOR_VIOLET);
-        gfx_printf("%s", display);
-    }
-
-    RESETCOLOR;
-
-    if (refresh){
-        length = strlen(display);
-        for (int i = 0; i < (42 - length); i++)
-            gfx_printf(" ");
-    }
-
-    if (file.property & ISDIR)
-        gfx_printf("\n");
-    else { 
-        SWAPCOLOR(COLOR_BLUE);
-        gfx_printf("\a%d\e%s", file.size, sizevalues[size - 4]);
-    }
-
-    free(display);
-}
-
-int makefilemenu(fs_entry *files, int amount, char *path){
-    int currentpos = -2, i, res = 0, offset = 0, quickoffset = 300;
-    u32 timer;
-    bool refresh = false;
-    clearscreen();
-    gfx_con_setpos(544, 0);
-    gfx_printf("%K%k%d / 500\n%K%k%s%k\n\n", COLOR_WHITE, COLOR_DEFAULT, amount, COLOR_DEFAULT, COLOR_GREEN, path, COLOR_DEFAULT);
-    while (1){
-        gfx_con_setpos(0, 47);
-        timer = get_tmr_ms();
-        for (i = -3 + offset; i < amount && i < 60 + offset; i++){
-            if (i < 0){
-                if (i == currentpos - 1)
-                    gfx_printf("%k%K%s%K\n", COLOR_ORANGE, COLOR_WHITE, fixedoptions[i + 3], COLOR_DEFAULT);
-                else
-                    gfx_printf("%k%K%s\n", COLOR_ORANGE, COLOR_DEFAULT, fixedoptions[i + 3]);
-            }
-            else
-                printfsentry(files[i], (i == currentpos - 1), refresh); 
-        }
-        refresh = false;
-        gfx_printf("\n%k%K %s %s\n\nTime taken for screen draw: %dms ", COLOR_BLUE, COLOR_DEFAULT, (offset + 60 < amount) ? "v" : " ", (offset > 0) ? "^" : " ", get_tmr_ms() - timer);
-
-        if (quickoffset == 300)
-            res = btn_wait();
-        else {
-            msleep(quickoffset);
-            res = btn_read();
-        }
-
-        if (res == 0)
-            quickoffset = 300;
-        else if (quickoffset > 46)
-            quickoffset -= 45;
-
-        if ((res & BTN_VOL_UP) && currentpos > -2){
-            currentpos--;
-            if (offset != 0 && currentpos < offset - 2){
-                offset--;
-                refresh = true;
-            }
-        }
-        if ((res & BTN_VOL_DOWN) && currentpos < amount){
-            currentpos++;
-            if (currentpos - offset > 60){
-                offset++;
-                refresh = true;
-            }
-        }
-        if (res & BTN_POWER)
-            return currentpos;
-    }
-    minerva_periodic_training();
-}
--- a/source/tegraexplorer/gfx.h
+++ b/source/tegraexplorer/gfx.h
@@ -1,13 +0,0 @@
-#pragma once
-#include "te.h"
-#include "fs.h"
-
-#define SWAPCOLOR(color) gfx_printf("%k", color)
-#define RESETCOLOR gfx_printf("%k%K", COLOR_WHITE, COLOR_DEFAULT)
-
-int makemenu(menu_item menu[], int menuamount);
-int message(char* message, u32 color);
-void clearscreen();
-int makefilemenu(fs_entry *files, int amount, char *path);
-void printbytes(u8 print[], u32 size, u32 offset);
-int makewaitmenu(char *initialmessage, char *hiddenmessage, int timer);
--- a/source/tegraexplorer/gfx/gfxutils.c
+++ b/source/tegraexplorer/gfx/gfxutils.c
@@ -0,0 +1,127 @@
+#include "gfxutils.h"
+#include <string.h>
+#include <stdarg.h>
+#include "menu.h"
+#include "../../gfx/gfx.h"
+#include "../../power/max17050.h"
+#include "../../utils/btn.h"
+#include "../../utils/util.h"
+#include "../../mem/heap.h"
+#include "../common/common.h"
+
+
+void gfx_clearscreen(){
+    int battery = 0;
+    max17050_get_property(MAX17050_RepSOC, &battery);
+
+    gfx_clear_grey(0x1B);
+    SWAPCOLOR(COLOR_DEFAULT);
+    SWAPBGCOLOR(COLOR_WHITE);
+
+    gfx_box(0, 1263, 719, 1279, COLOR_WHITE);
+    gfx_con_setpos(0, 1263);
+    gfx_printf("Move: Vol+/- | Select: Pow | Battery: %3d%%", battery >> 8);
+
+    gfx_box(0, 0, 719, 15, COLOR_WHITE);
+    gfx_con_setpos(0, 0);
+    gfx_printf("Tegraexplorer v1.4.0\n");
+
+    RESETCOLOR;
+}
+
+int gfx_message(u32 color, const char* message, ...){
+    va_list ap;
+    va_start(ap, message);
+
+    gfx_clearscreen();
+    SWAPCOLOR(color);
+
+    gfx_vprintf(message, ap);
+
+    va_end(ap);
+    return btn_wait();
+}
+
+int gfx_errDisplay(char *src_func, int err, int loc){
+    gfx_clearscreen();
+    SWAPCOLOR(COLOR_ORANGE);
+    gfx_printf("\nAn error occured:\n\n");
+    gfx_printf("Function: %s\nErrcode: %d\n", src_func, err);
+    
+    if (err < 15)
+        gfx_printf("Desc: %s\n", utils_err_codes[err]);
+    else if (err >= ERR_SAME_LOC && err <= ERR_FILE_TOO_BIG_FOR_DEST)
+        gfx_printf("Desc: %s\n", utils_err_codes_te[err - 50]);
+
+    if (loc)
+        gfx_printf("Loc: %d\n", loc);
+
+    gfx_printf("\nPress any button to return");
+
+    RESETCOLOR;
+    return btn_wait();
+}
+
+int gfx_makewaitmenu(char *hiddenmessage, int timer){
+    int res;
+    u32 start = get_tmr_s();
+
+    while (btn_read() != 0);
+
+    while(1){
+        res = btn_read();
+
+        if (res & BTN_VOL_DOWN || res & BTN_VOL_UP)
+            return 0;
+
+        if (start + timer > get_tmr_s())
+            gfx_printf("\r<Wait %d seconds> ", timer + start - get_tmr_s());
+
+        else if (res & BTN_POWER)
+            return 1;
+
+        else 
+            gfx_printf("\r%s", hiddenmessage);
+    }
+}
+
+void gfx_printlength(int size, char *toprint){
+    char *temp;
+    temp = (char*) malloc (size + 1);
+
+    if (strlen(toprint) > size){
+        strlcpy(temp, toprint, size);
+        memset(temp + size - 3, '.', 3);
+        memset(temp + size, '\0', 1);
+    }
+    else
+        strcpy(temp, toprint);
+
+    gfx_printf("%s", temp);
+    free(temp);
+}
+
+void gfx_printandclear(char *in, int length){
+    u32 x, y;
+
+    gfx_printlength(length, in);
+    gfx_con_getpos(&x, &y);
+    RESETCOLOR;
+
+    for (int i = (703 - x) / 16; i > 0; i--)
+        gfx_printf(" ");
+
+    gfx_con_setpos(x, y);
+
+    //gfx_box(x, y, 719, y + 16, COLOR_DEFAULT);
+    /*
+    u8 color = 0x1B;
+    gfx_set_rect_grey(&color, 719 - x, 16, x, y);
+    */
+}
+
+void gfx_printfilesize(int size, char *type){
+    SWAPCOLOR(COLOR_VIOLET);
+    gfx_printf("\a%4d\e%s", size, type);
+    RESETCOLOR;
+}
--- a/source/tegraexplorer/gfx/gfxutils.h
+++ b/source/tegraexplorer/gfx/gfxutils.h
@@ -0,0 +1,15 @@
+#pragma once
+#include "../../gfx/gfx.h"
+#include "../../utils/types.h"
+
+#define SWAPCOLOR(color) gfx_printf("%k", color)
+#define SWAPBGCOLOR(color) gfx_printf("%K", color)
+#define RESETCOLOR gfx_printf("%k%K", COLOR_WHITE, COLOR_DEFAULT)
+
+void gfx_clearscreen();
+int gfx_message(u32 color, const char* message, ...);
+int gfx_errDisplay(char *src_func, int err, int loc);
+int gfx_makewaitmenu(char *hiddenmessage, int timer);
+void gfx_printlength(int size, char *toprint);
+void gfx_printandclear(char *in, int length);
+void gfx_printfilesize(int size, char *type);
--- a/source/tegraexplorer/gfx/menu.c
+++ b/source/tegraexplorer/gfx/menu.c
@@ -0,0 +1,147 @@
+#include "menu.h"
+#include "gfxutils.h"
+#include "../common/types.h"
+#include "../../utils/btn.h"
+#include "../common/common.h"
+#include "../../utils/util.h"
+#include "../../mem/minerva.h"
+
+void _printentry(menu_entry entry, bool highlighted, bool refresh){
+    int size;
+    u32 color = (entry.property & ISMENU) ? entry.storage : ((entry.property & ISDIR) ? COLOR_WHITE : COLOR_VIOLET);
+    /*
+    if (entry.property & ISMENU)
+        SWAPCOLOR(entry.storage);
+    else if (entry.property & ISDIR)
+        SWAPCOLOR(COLOR_WHITE);
+    else {
+        SWAPCOLOR(COLOR_VIOLET);
+    }
+    */
+
+   if (!(entry.property & ISMENU && entry.property & ISDIR)){
+        for (size = 4; size < 8; size++)
+            if ((entry.property & (1 << size)))
+                break;
+   }
+
+        
+    /*
+    if (highlighted){
+        SWAPBGCOLOR(COLOR_WHITE);
+        if ((entry.property & ISMENU) ? entry.storage == COLOR_WHITE : entry.property & ISDIR)
+            SWAPCOLOR(COLOR_DEFAULT);
+    }
+    else
+        SWAPBGCOLOR(COLOR_DEFAULT);
+    */
+   SWAPCOLOR((highlighted) ? COLOR_DEFAULT : color);
+   SWAPBGCOLOR((highlighted) ? color : COLOR_DEFAULT);
+        
+
+    if (refresh)
+        gfx_printandclear(entry.name, 37);
+    else
+        gfx_printlength(37, entry.name);
+
+    if (entry.property & ISDIR || entry.property & ISMENU)
+        gfx_printf("\n");
+    else { 
+        SWAPCOLOR(COLOR_BLUE);
+        SWAPBGCOLOR(COLOR_DEFAULT);
+        gfx_printf("\a%d\e%s", entry.storage, gfx_file_size_names[size - 4]);
+    }   
+}
+
+int menu_make(menu_entry *entries, int amount, char *toptext){
+    int currentpos = 0, res = 0, offset = 0, delay = 300, minscreen = 0, maxscreen = 59;
+    u32 scrolltimer, timer;
+    bool refresh = false;
+
+    gfx_clearscreen();
+
+    gfx_con_setpos(512, 0);
+    SWAPCOLOR(COLOR_DEFAULT);
+    SWAPBGCOLOR(COLOR_WHITE);
+    gfx_printf("%3d entries\n", amount);
+    RESETCOLOR;
+
+    SWAPCOLOR(COLOR_GREEN);
+    gfx_printlength(42, toptext);
+    RESETCOLOR;
+
+    while (!(res & BTN_POWER)){
+        gfx_con_setpos(0, 47);
+        timer = get_tmr_ms();
+        refresh = false;
+
+        if (!currentpos){
+            while (currentpos < amount && entries[currentpos].property & (ISSKIP | ISHIDE))
+                currentpos++;
+        }
+        if (currentpos == amount - 1){
+            while (currentpos >= 1 && entries[currentpos].property & (ISSKIP | ISHIDE))
+                currentpos--;
+        }
+
+        if (currentpos > maxscreen){
+            offset += currentpos - maxscreen;
+            minscreen += currentpos - maxscreen;
+            maxscreen += currentpos - maxscreen;
+            refresh = true;
+        }
+
+        if (currentpos < minscreen){
+            offset -= minscreen - currentpos;
+            maxscreen -= minscreen - currentpos;
+            minscreen -= minscreen - currentpos;      
+            refresh = true;
+        }
+
+        for (int i = 0 + offset; i < amount && i < 60 + offset; i++)
+            if (!(entries[i].property & ISHIDE))
+                _printentry(entries[i], (i == currentpos), refresh);
+
+        gfx_printf("\n%k%K %s %s\n\nTime taken for screen draw: %dms", COLOR_BLUE, COLOR_DEFAULT, (offset + 60 < amount) ? "v" : " ", (offset > 0) ? "^" : " ", get_tmr_ms() - timer);
+
+        while (btn_read() & BTN_POWER);
+
+        res = 0;
+        while (!res){
+            res = btn_read();
+
+            if (!res)
+                delay = 300;
+            
+            if (delay < 300){
+                scrolltimer = get_tmr_ms();
+                while (res){
+                    if (scrolltimer + delay <= get_tmr_ms())
+                        break;
+
+                    res = btn_read();         
+                }
+            }
+
+            if (delay > 46 && res)
+                delay -= 45;
+        }
+
+        if (res & BTN_VOL_UP && currentpos >= 1){
+            currentpos--;
+            while(entries[currentpos].property & (ISSKIP | ISHIDE) && currentpos >= 1)
+                currentpos--;
+        }
+            
+        else if (res & BTN_VOL_DOWN && currentpos < amount - 1){
+            currentpos++;
+            while(entries[currentpos].property & (ISSKIP | ISHIDE) && currentpos < amount - 1)
+                currentpos++;
+        }
+
+    }
+
+    minerva_periodic_training();
+    //return (mode) ? currentpos : entries[currentpos].property;
+    return currentpos;
+}
--- a/source/tegraexplorer/gfx/menu.h
+++ b/source/tegraexplorer/gfx/menu.h
@@ -0,0 +1,4 @@
+#pragma once
+#include "../common/types.h"
+
+int menu_make(menu_entry *entries, int amount, char *toptext);
--- a/source/tegraexplorer/mainmenu.c
+++ b/source/tegraexplorer/mainmenu.c
@@ -0,0 +1,188 @@
+#include <stdio.h>
+#include <string.h>
+#include "mainmenu.h"
+#include "../utils/util.h"
+#include "utils/tools.h"
+#include "../utils/btn.h"
+#include "emmc/emmc.h"
+#include "../storage/emummc.h"
+#include "utils/script.h"
+
+#include "common/common.h"
+#include "gfx/menu.h"
+
+#include "utils/utils.h"
+#include "gfx/gfxutils.h"
+#include "fs/fsutils.h"
+#include "fs/fsmenu.h"
+#include "emmc/emmcoperations.h"
+
+extern bool sd_mount();
+extern void sd_unmount();
+extern bool return_sd_mounted(int value);
+extern int launch_payload(char *path);
+
+int res = 0, meter = 0;
+
+void MainMenu_SDCard(){
+    fileexplorer("SD:/", 0);
+}
+
+void MainMenu_EMMC(){
+    gfx_clearscreen();
+    gfx_printf("You're about to enter EMMC\nModifying anything here\n        can result in a BRICK!\n\nPlease only continue\n    if you know what you're doing\n\nPress Vol+/- to return\n");
+    if (gfx_makewaitmenu("Press Power to enter", 4)){
+        connect_mmc(SYSMMC);
+
+        if (!mount_mmc(emmc_fs_entries[res - 2], res - 1))
+            fileexplorer("emmc:/", 1);
+    }
+}
+
+void MainMenu_EMUMMC(){
+    connect_mmc(EMUMMC);
+
+    if (!mount_mmc(emmc_fs_entries[res - 5], res - 4))
+        fileexplorer("emmc:/", 1);   
+}
+
+void MainMenu_MountSD(){
+    if (return_sd_mounted(1))
+        sd_unmount();
+    else
+        sd_mount();
+}
+
+void MainMenu_Tools(){
+    //res = makemenu(toolsmenu, 8);
+    res = menu_make(mainmenu_tools, 6, "-- Tools Menu --");
+
+    switch(res){
+        case TOOLS_DISPLAY_INFO:
+            displayinfo();
+            break;
+        case TOOLS_DISPLAY_GPIO:
+            displaygpio();
+            break;
+        case TOOLS_DUMPFIRMWARE:
+            dumpfirmware(SYSMMC);
+            break;
+        case TOOLS_DUMPUSERSAVE:
+            if ((res = utils_mmcMenu()) > 0)
+                dumpusersaves(res);
+
+            break;
+        case TOOLS_DUMP_BOOT:
+            dump_emmc_parts(PART_BOOT | PART_PKG2, SYSMMC);
+            break;
+    }
+}
+
+void MainMenu_SDFormat(){
+    //res = makemenu(formatmenu, 4);
+    res = menu_make(mainmenu_format, 3, "-- Format Menu --");
+
+    if (res > 0){
+        gfx_clearscreen();
+        gfx_printf("Are you sure you want to format your sd?\nThis will delete everything on your SD card\nThis action is irreversible!\n\nPress Vol+/- to cancel\n");
+        if(gfx_makewaitmenu("Press Power to continue", 10)){
+            if (format(res)){
+                sd_unmount();
+            }
+        }
+    }
+}
+
+void MainMenu_Credits(){
+    if (++meter >= 3)
+        gfx_errDisplay("credits", 53, 0);
+    gfx_message(COLOR_WHITE, mainmenu_credits);
+}
+
+void MainMenu_Exit(){
+    if (return_sd_mounted(1)){
+        SETBIT(mainmenu_shutdown[4].property, ISHIDE, !fsutil_checkfile("/bootloader/update.bin"));
+        SETBIT(mainmenu_shutdown[5].property, ISHIDE, !fsutil_checkfile("/atmosphere/reboot_payload.bin"));
+    }
+    else {
+        for (int i = 4; i <= 5; i++)
+            SETBIT(mainmenu_shutdown[i].property, ISHIDE, 1);
+    }
+
+    res = menu_make(mainmenu_shutdown, 6, "-- Shutdown Menu --");
+
+    switch(res){
+        case SHUTDOWN_REBOOT_RCM:
+            reboot_rcm();
+                    
+        case SHUTDOWN_REBOOT_NORMAL:
+            reboot_normal();
+
+        case SHUTDOWN_POWER_OFF:
+            power_off();
+
+        case SHUTDOWN_HEKATE:
+            launch_payload("/bootloader/update.bin");
+                    
+        case SHUTDOWN_AMS:
+            launch_payload("/atmosphere/reboot_payload.bin");
+    } //todo declock bpmp
+}
+
+part_handler mainmenu_functions[] = {
+    MainMenu_SDCard,
+    MainMenu_EMMC,
+    MainMenu_EMMC,
+    MainMenu_EMMC,
+    MainMenu_EMUMMC,
+    MainMenu_EMUMMC,
+    MainMenu_EMUMMC,
+    MainMenu_MountSD,
+    MainMenu_Tools,
+    MainMenu_SDFormat,
+    MainMenu_Credits,
+    MainMenu_Exit,
+};
+
+void RunMenuOption(int option){
+    if (option != 11)
+        meter = 0;
+    if (option > 0)
+        mainmenu_functions[option - 1]();
+}
+void te_main(){
+    int setter;
+
+    if (dump_biskeys() == -1){
+        gfx_errDisplay("dump_biskey", ERR_BISKEY_DUMP_FAILED, 0);
+        for (int i = 1; i <= 3; i++)
+            mainmenu_main[i].property |= ISHIDE;
+    }
+
+    if (emummc_load_cfg()){
+        for (int i = 4; i <= 6; i++)
+            mainmenu_main[i].property |= ISHIDE;
+    }
+
+    disconnect_mmc();
+
+    while (1){
+        //fillmainmenu();
+
+        setter = return_sd_mounted(1);
+
+        if (emu_cfg.enabled){
+            for (int i = 4; i <= 6; i++)
+                SETBIT(mainmenu_main[i].property, ISHIDE, !setter);
+        }
+
+        SETBIT(mainmenu_main[0].property, ISHIDE, !setter);
+        mainmenu_main[7].name = (menu_sd_states[!setter]);
+
+        setter = return_sd_mounted(10);
+        SETBIT(mainmenu_main[9].property, ISHIDE, !setter);
+
+        res = menu_make(mainmenu_main, 12, "-- Main Menu --") + 1;
+        RunMenuOption(res);
+    }
+}
--- a/source/tegraexplorer/mainmenu.h
+++ b/source/tegraexplorer/mainmenu.h
@@ -1,9 +1,9 @@
 #pragma once
 #include "../utils/types.h"

-#define MAINMENU_AMOUNT 9
-#define CREDITS_MESSAGE "\nTegraexplorer, made by:\nSuch Meme, Many Skill\n\nProject based on:\nLockpick_RCM\nHekate\n\nCool people:\nshchmue\ndennthecafebabe\nDax"
+#define MAINMENU_AMOUNT 12

+/*
 typedef struct _menu_item {
    char name[50];
    u32 color;
@@ -11,11 +11,15 @@ typedef struct _menu_item {
    short property;
 } menu_item;

+
 enum mainmenu_return {
    SD_CARD = 1,
    EMMC_SAF,
    EMMC_SYS,
    EMMC_USR,
+    EMUMMC_SAF,
+    EMUMMC_SYS,
+    EMUMMC_USR,
    MOUNT_SD,
    TOOLS,
    SD_FORMAT,
@@ -34,14 +38,16 @@ enum shutdownmenu_return {
 enum toolsmenu_return {
    DISPLAY_INFO = 1,
    DISPLAY_GPIO,
-    DUMPFIRMWARE
+    DUMPFIRMWARE,
+    DUMPUSERSAVE,
+    DUMP_BOOT,
+    RESTORE_BOOT
 };

 enum formatmenu_return {
    FORMAT_EMUMMC = 0,
    FORMAT_ALL_FAT32
 };
-
-//menu_item mainmenu[MAINMENU_AMOUNT];
+*/

 void te_main();
--- a/source/tegraexplorer/te.c
+++ b/source/tegraexplorer/te.c
@@ -1,198 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include "te.h"
-#include "gfx.h"
-#include "../utils/util.h"
-#include "tools.h"
-#include "fs.h"
-#include "../utils/btn.h"
-#include "emmc.h"
-
-extern bool sd_mount();
-extern void sd_unmount();
-extern bool return_sd_mounted(int value);
-extern int launch_payload(char *path);
-
-menu_item mainmenu[MAINMENU_AMOUNT] = {
-    {"[SD:/] SD CARD\n", COLOR_GREEN, SD_CARD, 1},
-    {"[SYSTEM:/] EMMC", COLOR_ORANGE, EMMC_SYS, 1},
-    {"[USER:/] EMMC", COLOR_ORANGE, EMMC_USR, 1},
-    {"[SAFE:/] EMMC", COLOR_ORANGE, EMMC_SAF, 1},
-    {"\nMount/Unmount SD", COLOR_WHITE, MOUNT_SD, 1},
-    {"Tools", COLOR_VIOLET, TOOLS, 1},
-    {"SD format", COLOR_VIOLET, SD_FORMAT, 1},
-    {"\nCredits", COLOR_WHITE, CREDITS, 1},
-    {"Exit", COLOR_WHITE, EXIT, 1}
-};
-
-menu_item shutdownmenu[7] = {
-    {"-- EXIT --\n", COLOR_ORANGE, -1, 0},
-    {"Back", COLOR_WHITE, -1, 1},
-    {"\nReboot to RCM", COLOR_VIOLET, REBOOT_RCM, 1},
-    {"Reboot normally", COLOR_ORANGE, REBOOT_NORMAL, 1},
-    {"Power off\n", COLOR_BLUE, POWER_OFF, 1},
-    {"Reboot to Hekate", COLOR_GREEN, HEKATE, -1},
-    {"Reboot to Atmosphere", COLOR_GREEN, AMS, -1}
-};
-
-menu_item toolsmenu[5] = {
-    {"-- TOOLS --\n", COLOR_VIOLET, -1, 0},
-    {"Back", COLOR_WHITE, -1, 1},
-    {"\nDisplay Console Info", COLOR_GREEN, DISPLAY_INFO, 1},
-    {"Display GPIO pins", COLOR_VIOLET, DISPLAY_GPIO, 1},
-    {"Dump Firmware", COLOR_BLUE, DUMPFIRMWARE, 1}
-};
-
-menu_item formatmenu[4] = {
-    {"-- FORMAT SD --\n", COLOR_RED, -1, 0},
-    {"Back\n", COLOR_WHITE, -1, 1},
-    {"Format entire SD to FAT32", COLOR_RED, FORMAT_ALL_FAT32, 1},
-    {"Format for EmuMMC setup (FAT32/RAW)", COLOR_RED, FORMAT_EMUMMC, 1}
-};
-
-const char emmc_entries[3][8] = {
-    "SAFE",
-    "SYSTEM",
-    "USER"
-};
-
-void fillmainmenu(){
-    int i;
-
-    for (i = 0; i < MAINMENU_AMOUNT; i++){
-        switch (i + 1) {
-            case 1:
-            case 7:
-                if (return_sd_mounted(i + 1))
-                    mainmenu[i].property = 1;
-                else
-                    mainmenu[i].property = -1;
-                break;
-            case 5:
-                if (return_sd_mounted(1)){
-                    mainmenu[i].property = 2;
-                    strcpy(mainmenu[i].name, "\nUnmount SD");
-                }
-                else {
-                    mainmenu[i].property = 1;
-                    strcpy(mainmenu[i].name, "\nMount SD");
-                }
-                break;
-        }
-    }
-}
-
-void te_main(){
-    int res;
-
-    if (dump_biskeys() == -1){
-        message("Biskeys failed to dump!\nEmmc will not be mounted!", COLOR_RED);
-        mainmenu[1].property = -1;
-        mainmenu[2].property = -1;
-        mainmenu[3].property = -1;
-    }
-
-    while (1){
-        fillmainmenu();
-        res = makemenu(mainmenu, MAINMENU_AMOUNT);
-
-        switch(res){
-            case SD_CARD:
-                filemenu("SD:/");
-                break;
-            
-            case EMMC_SAF:
-            case EMMC_SYS:
-            case EMMC_USR:
-
-            if (makewaitmenu("You're about to enter EMMC\nModifying anything here\n        can result in a BRICK!\n\nPlease only continue\n    if you know what you're doing\n\nPress Vol+/- to return\n", "Press Power to enter", 4)){
-                if (!mount_emmc(emmc_entries[res - 2], res - 1)){
-                    filemenu("emmc:/");
-                }
-                else
-                    message("EMMC failed to mount!", COLOR_RED);
-            }
-
-            break;
-
-            case MOUNT_SD:
-                if (return_sd_mounted(1))
-                    sd_unmount();
-                else
-                    sd_mount();
-
-                break;
-
-            case TOOLS:
-                res = makemenu(toolsmenu, 5);
-
-                switch(res){
-                    case DISPLAY_INFO:
-                        displayinfo();
-                        break;
-                    case DISPLAY_GPIO:
-                        displaygpio();
-                        break;
-                    case DUMPFIRMWARE:
-                        dumpfirmware();
-                        break;
-                }
-                break;
-            
-            case SD_FORMAT:
-                res = makemenu(formatmenu, 4);
-
-                if (res >= 0){
-                    if(makewaitmenu("Are you sure you want to format your sd?\nThis will delete everything on your SD card\nThis action is irreversible!\n\nPress Vol+/- to cancel\n", "Press Power to continue", 10)){
-                        if (format(res)){
-                            sd_unmount();
-                        }
-                    }
-                }
-
-                break;
-
-            case CREDITS:
-                message(CREDITS_MESSAGE, COLOR_WHITE);
-                break;
-
-            case EXIT:
-                if (return_sd_mounted(1)){  
-                    if (checkfile("/bootloader/update.bin"))
-                        shutdownmenu[5].property = 1;
-                    else
-                        shutdownmenu[5].property = -1;
-
-                    if (checkfile("/atmosphere/reboot_payload.bin"))
-                        shutdownmenu[6].property = 1;
-                    else
-                        shutdownmenu[6].property = -1;
-                }
-                else {
-                    shutdownmenu[5].property = -1;
-                    shutdownmenu[6].property = -1;
-                }
-
-                res = makemenu(shutdownmenu, 7);
-
-                switch(res){
-                    case REBOOT_RCM:
-                        reboot_rcm();
-                    
-                    case REBOOT_NORMAL:
-                        reboot_normal();
-
-                    case POWER_OFF:
-                        power_off();
-
-                    case HEKATE:
-                        launch_payload("/bootloader/update.bin");
-                    
-                    case AMS:
-                        launch_payload("/atmosphere/reboot_payload.bin");
-                } //todo declock bpmp
-
-                break;
-        }
-    }
-}
--- a/source/tegraexplorer/utils/script.c
+++ b/source/tegraexplorer/utils/script.c
@@ -0,0 +1,283 @@
+#include <string.h>
+#include "../../mem/heap.h"
+#include "../gfx/gfxutils.h"
+#include "../emmc/emmc.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/sprintf.h"
+#include "../../utils/btn.h"
+#include "../../gfx/gfx.h"
+#include "../../utils/util.h"
+#include "../../storage/emummc.h"
+#include "script.h"
+#include "../common/common.h"
+#include "../fs/fsactions.h"
+
+#include <stdlib.h>
+
+char func[11] = "", args[2][128] = {"", ""};
+int res, errcode;
+const int scriptver = 140;
+bool forceExit = false;
+u32 currentcolor;
+
+void Part_CheckFile(){
+    FILINFO fno;
+    errcode = f_stat(args[0], &fno);
+}
+
+void Part_SetColor(){
+    if (strcmpcheck(args[0], "RED"))
+        currentcolor = COLOR_RED;
+    else if (strcmpcheck(args[0], "ORANGE"))
+        currentcolor = COLOR_ORANGE;
+    else if (strcmpcheck(args[0], "YELLOW"))
+        currentcolor = COLOR_YELLOW;
+    else if (strcmpcheck(args[0], "GREEN"))
+        currentcolor = COLOR_GREEN;
+    else if (strcmpcheck(args[0], "BLUE"))
+        currentcolor = COLOR_BLUE;
+    else if (strcmpcheck(args[0], "VIOLET"))
+        currentcolor = COLOR_VIOLET;
+    else if (strcmpcheck(args[0], "WHITE"))
+        currentcolor = COLOR_WHITE;
+}
+
+void Part_Wait(){
+    int waitamount, begintime;
+    SWAPCOLOR(currentcolor);
+
+    waitamount = atoi(args[0]);
+    begintime = get_tmr_s();
+
+    while (begintime + waitamount > get_tmr_s()){
+        gfx_printf("\r<Wait %d seconds> ", (begintime + waitamount) - get_tmr_s());
+    }
+
+    gfx_printf("\r                 \r");
+}
+
+void Part_VersionCheck(){
+    int givenversion = atoi(args[0]);
+
+    if (givenversion > scriptver){
+        gfx_printf("Script required version is too high\nUpdate TegraExplorer!");
+        btn_wait();
+        forceExit = true;
+    }
+}
+
+void Part_Move(){
+    errcode = f_rename(args[0], args[1]);
+    if (errcode)
+        f_rename(args[0], args[1]);
+}
+
+void Part_Delete(){
+    errcode = f_unlink(args[0]);
+    if (errcode)
+        f_unlink(args[0]);
+}
+
+void Part_DeleteRecursive(){
+    errcode = fsact_del_recursive(args[0]);
+}
+
+void Part_Copy(){
+    errcode = fsact_copy(args[0], args[1], COPY_MODE_PRINT); 
+}
+
+void Part_RecursiveCopy(){
+    errcode = fsact_copy_recursive(args[0], args[1]);
+}
+
+void Part_MakeFolder(){
+    errcode = f_mkdir(args[0]);
+    if (errcode)
+        f_mkdir(args[0]);
+}
+
+void Part_ConnectMMC(){
+    if (strcmpcheck(args[0], "SYSMMC"))
+        connect_mmc(SYSMMC);
+    if (strcmpcheck(args[0], "EMUMMC"))
+        connect_mmc(EMUMMC);
+}
+
+void Part_MountMMC(){
+    errcode = mount_mmc(args[0], 2);
+}
+
+void Part_Print(){
+    RESETCOLOR;
+    SWAPCOLOR(currentcolor);
+    gfx_printf("%s\n", args[0]);
+}
+
+void Part_ErrorPrint(){
+    RESETCOLOR;
+    SWAPCOLOR(COLOR_RED);
+    gfx_printf("Errorcode: %d\n", errcode);
+}
+
+void Part_Exit(){
+    forceExit = true;
+}
+
+u8 buttons_pressed = 0;
+void Part_WaitOnUser(){
+    buttons_pressed = btn_wait();
+}
+
+script_parts parts[] = {
+    {"COPY", Part_Copy, 2},
+    {"COPY-R", Part_RecursiveCopy, 2},
+    {"MKDIR", Part_MakeFolder, 1},
+    {"CON_MMC", Part_ConnectMMC, 1},
+    {"MNT_MMC", Part_MountMMC, 1},
+    {"PRINT", Part_Print, 1},
+    {"ERRPRINT", Part_ErrorPrint, 0},
+    {"EXIT", Part_Exit, 0},
+    {"PAUSE", Part_WaitOnUser, 0},
+    {"DEL", Part_Delete, 1},
+    {"DEL-R", Part_DeleteRecursive, 1},
+    {"MOVE", Part_Move, 2},
+    {"VERSION", Part_VersionCheck, 1},
+    {"WAIT", Part_Wait, 1},
+    {"COLOR", Part_SetColor, 1},
+    {"CHECKPATH", Part_CheckFile, 1},
+    {"NULL", NULL, -1}
+};
+
+int ParsePart(){
+    int i;
+    for (i = 0; parts[i].arg_amount != -1; i++){
+        if (strcmpcheck(func, parts[i].name))
+            return i;
+    }
+    gfx_printf("Parsing error...\nPress any key to continue");
+    btn_wait();
+    forceExit = true;
+    return -1;
+}
+
+FIL in;
+UINT endByte = 0;
+
+char GetNextByte(){
+    char single;
+    f_read(&in, &single, sizeof(char), &endByte);
+    
+    if (sizeof(char) != endByte)
+        forceExit = true;
+
+    return single;
+}
+
+void ParseScript(char* path){
+    char currentchar;
+    int strlength;
+    bool inifstatement = false;
+    forceExit = false;
+    currentcolor = COLOR_WHITE;
+    
+    gfx_clearscreen();
+
+    res = f_open(&in, path, FA_READ | FA_OPEN_EXISTING);
+    if (res != FR_OK){
+        gfx_errDisplay("ParseScript", res, 1);
+        return;
+    }
+
+    while (!forceExit){
+        currentchar = GetNextByte();
+
+        if (endByte == 0 || currentchar == (char)EOF)
+            break;
+
+        switch(currentchar){
+            case '{':
+                if (!inifstatement)
+                    while (currentchar != '}')
+                        currentchar = GetNextByte();
+                
+                break;
+            case '}':
+                if (inifstatement)
+                    inifstatement = false;
+
+                break;
+            case '<':
+                strlength = 0;
+                currentchar = GetNextByte();
+
+                while (currentchar != '>'){
+                    func[strlength++] = currentchar;
+                    currentchar = GetNextByte();
+                }
+                func[strlength] = '\0';
+
+                res = ParsePart();
+                if (res == -1)
+                    break;
+                
+                for (int i = 0; i < parts[res].arg_amount; i++){
+                    while (currentchar != 0x22)
+                        currentchar = GetNextByte();
+                    
+                    strlength = 0;
+                    currentchar = GetNextByte();
+                    while (currentchar != 0x22){
+                        args[i][strlength++] = currentchar;
+                        currentchar = GetNextByte();
+                    }
+                    args[i][strlength] = '\0';  
+
+                    if (i < parts[res].arg_amount)
+                        currentchar = GetNextByte();              
+                }
+                parts[res].handler();
+                break;
+            case '$':
+                strlength = 0;
+                currentchar = GetNextByte();
+                
+                while (currentchar != '$'){
+                    func[strlength++] = currentchar;
+                    currentchar = GetNextByte();
+                }
+                func[strlength] = '\0';
+
+                if (strcmpcheck(func, "ERROR") || strcmpcheck(func, "TRUE")){
+                    inifstatement = (errcode);
+                }
+                else if (strcmpcheck(func, "NOERROR") || strcmpcheck(func, "FALSE")){
+                    inifstatement = (!errcode);
+                }
+                else if (strcmpcheck(func, "BTN_POWER")){
+                    inifstatement = (buttons_pressed & BTN_POWER);
+                }
+                else if (strcmpcheck(func, "BTN_VOL+")){
+                    inifstatement = (buttons_pressed & BTN_VOL_UP);
+                }
+                else if (strcmpcheck(func, "BTN_VOL-")){
+                    inifstatement = (buttons_pressed & BTN_VOL_DOWN);
+                }
+                else if (strcmpcheck(func, "EMUMMC")){
+                    inifstatement = (emu_cfg.enabled);
+                }
+                else if (strcmpcheck(func, "NOEMUMMC")){
+                    inifstatement = (!emu_cfg.enabled);
+                }
+
+                if (inifstatement)
+                    while(currentchar != '{')
+                        currentchar = GetNextByte();
+                
+                break;
+
+        }
+    }
+
+    f_close(&in);
+}
--- a/source/tegraexplorer/utils/script.h
+++ b/source/tegraexplorer/utils/script.h
@@ -0,0 +1,11 @@
+#pragma once
+#define strcmpcheck(x, y) (!strcmp(x, y))
+
+typedef void (*part_handler)();
+typedef struct _script_parts {
+    char name[11];
+    part_handler handler;
+    short arg_amount;
+} script_parts;
+
+void ParseScript(char* path);
--- a/source/tegraexplorer/utils/tools.c
+++ b/source/tegraexplorer/utils/tools.c
@@ -1,29 +1,31 @@
 #include "tools.h"
-#include "gfx.h"
-#include "../libs/fatfs/ff.h"
-#include "../gfx/gfx.h"
-#include "../utils/btn.h"
-#include "../soc/gpio.h"
-#include "../utils/util.h"
-#include "../utils/types.h"
-#include "../libs/fatfs/diskio.h"
-#include "../storage/sdmmc.h"
-#include "../utils/sprintf.h"
-#include "../soc/fuse.h"
-#include "emmc.h"
-#include "fs.h"
+#include "../gfx/gfxutils.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../gfx/gfx.h"
+#include "../../utils/btn.h"
+#include "../../soc/gpio.h"
+#include "../../utils/util.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/diskio.h"
+#include "../../storage/sdmmc.h"
+#include "../../utils/sprintf.h"
+#include "../../soc/fuse.h"
+#include "../emmc/emmc.h"
+#include "../common/common.h"
+#include "../fs/fsactions.h"

 extern bool sd_mount();
 extern void sd_unmount();
 extern sdmmc_storage_t sd_storage;

 void displayinfo(){
-    clearscreen();
+    gfx_clearscreen();

    FATFS *fs;
    DWORD fre_clust, fre_sect, tot_sect;
    u32 capacity;
    u8 fuse_count = 0;
+    pkg1_info pkg1 = returnpkg1info();
    int res;

    for (u32 i = 0; i < 32; i++){
@@ -33,7 +35,7 @@ void displayinfo(){

    SWAPCOLOR(COLOR_ORANGE);

-    gfx_printf("Fuse count: %d\nPKG1 version: %d\n\n", fuse_count, returnpkg1ver());
+    gfx_printf("Fuse count: %d\nPKG1 version: %d\nPKG1 id: %s\n\n", fuse_count, pkg1.ver, pkg1.id);
    print_biskeys();

    RESETCOLOR;
@@ -65,7 +67,7 @@ void displayinfo(){

 void displaygpio(){
    int res;
-    clearscreen();
+    gfx_clearscreen();
    gfx_printf("Updates gpio pins every 50ms:\nPress power to exit");
    msleep(200);
    while (1){
@@ -84,7 +86,7 @@ void displaygpio(){
    }
 }

-int dumpfirmware(){
+int dumpfirmware(int mmc){
    DIR dir;
    FILINFO fno;
    bool fail = false;
@@ -93,13 +95,14 @@ int dumpfirmware(){
    char sdfolderpath[100] = "";
    char syspath[100] = "";
    char sdpath[100] = "";
-    short pkg1ver = returnpkg1ver();
+    pkg1_info pkg1 = returnpkg1info();
    u32 timer = get_tmr_s();

-    clearscreen();
-    mount_emmc("SYSTEM", 2);
+    gfx_clearscreen();
+    connect_mmc(mmc);
+    mount_mmc("SYSTEM", 2);

-    gfx_printf("PKG1 version: %d\n", pkg1ver);
+    gfx_printf("PKG1 version: %d\n", pkg1.ver);

    ret = f_mkdir("sd:/tegraexplorer");
    gfx_printf("Creating sd:/tegraexplorer %d\n", ret);
@@ -107,7 +110,7 @@ int dumpfirmware(){
    ret = f_mkdir("sd:/tegraexplorer/Firmware");
    gfx_printf("Creating sd:/tegraexplorer/Firmware %d\n", ret);

-    sprintf(sdfolderpath, "sd:/tegraexplorer/Firmware/%d", pkg1ver);
+    sprintf(sdfolderpath, "sd:/tegraexplorer/Firmware/%d (%s)", pkg1.ver, pkg1.id);
    ret = f_mkdir(sdfolderpath);
    gfx_printf("Creating %s %d\n", sdfolderpath, ret);

@@ -122,7 +125,7 @@ int dumpfirmware(){
        else
            sprintf(syspath, "%s/%s", path, fno.fname);

-        ret = copy(syspath, sdpath, false);
+        ret = fsact_copy(syspath, sdpath, 0);

        gfx_printf("%d %s\r", ++amount, fno.fname);

@@ -140,31 +143,63 @@ int dumpfirmware(){
    return fail;
 }

+void dumpusersaves(int mmc){
+    int res;
+
+    connect_mmc(mmc);
+    mount_mmc("USER", 2);
+    gfx_clearscreen();
+
+    res = f_mkdir("sd:/tegraexplorer");
+    gfx_printf("Creating sd:/tegraexplorer, res: %d\nCopying:\n", res);
+
+    SWAPCOLOR(COLOR_GREEN);
+
+    res = fsact_copy_recursive("emmc:/save", "sd:/tegraexplorer");
+
+    SWAPCOLOR(COLOR_ORANGE);
+    gfx_printf("\rResult copy_recursive() %d\n\n", res);
+
+    if (res){
+        SWAPCOLOR(COLOR_RED);
+        gfx_printf("Dump failed!\n");
+    }
+    else
+        gfx_printf("Saves are located in SD:/tegraexplorer/save\n");
+
+    gfx_printf("Press any key to continue");
+    btn_wait();
+}
+
 int format(int mode){
-    clearscreen();
+    gfx_clearscreen();
    int res;
    bool fatalerror = false;
    DWORD plist[] = {666, 61145088};
-    u32 timer, totalsectors;
+    u32 timer, totalsectors, alignedsectors, extrasectors;
    BYTE work[FF_MAX_SS];
    DWORD clustsize = 32768;
    BYTE formatoptions = 0;
    formatoptions |= (FM_FAT32);
    //formatoptions |= (FM_SFD);

-    disconnect_emmc();
+    disconnect_mmc();

    timer = get_tmr_s();
    totalsectors = sd_storage.csd.capacity;

-    if (mode == 0){
+    if (mode == FORMAT_EMUMMC){
        if (totalsectors < 83886080){
            gfx_printf("%kYou seem to be running this on a <=32GB SD\nNot enough free space for emummc!", COLOR_RED);
            fatalerror = true;
        }
        else {
-            plist[0] = totalsectors - 61145088;
-            gfx_printf("\nStarting SD partitioning:\nTotalSectors:        %d\nPartition1 (SD):     %d\nPartition2 (EMUMMC): %d\n", totalsectors, plist[0], plist[1]);
+            totalsectors -= plist[1];
+            alignedsectors = (totalsectors / 2048) * 2048;
+            extrasectors = totalsectors - alignedsectors;
+            plist[0] = alignedsectors;
+            plist[1] += extrasectors;
+            gfx_printf("\nStarting SD partitioning:\nTotalSectors:        %d\nPartition1 (SD):     %d\nPartition2 (EMUMMC): %d\n", plist[0] + plist[1], plist[0], plist[1]);
        }
    }
    else {
@@ -206,8 +241,7 @@ int format(int mode){
        }
    }

-    dump_biskeys();
-    mount_emmc("SYSTEM", 2);
+    connect_mmc(SYSMMC);

    gfx_printf("\nPress any button to return%k\nTotal time taken: %ds", COLOR_WHITE, (get_tmr_s() - timer));
    btn_wait();
--- a/source/tegraexplorer/utils/tools.h
+++ b/source/tegraexplorer/utils/tools.h
@@ -3,4 +3,5 @@
 void displayinfo();
 void displaygpio();
 int format(int mode);
-int dumpfirmware();
+int dumpfirmware(int mmc);
+void dumpusersaves(int mmc);
--- a/source/tegraexplorer/utils/utils.c
+++ b/source/tegraexplorer/utils/utils.c
@@ -0,0 +1,19 @@
+#include <string.h>
+#include "utils.h"
+#include "../common/common.h"
+#include "../gfx/menu.h"
+#include "../../storage/emummc.h"
+#include "../../mem/heap.h"
+
+int utils_mmcMenu(){
+    if (emu_cfg.enabled)
+        return menu_make(utils_mmcChoice, 3, "-- Choose MMC --");    
+    else
+        return SYSMMC;
+}
+
+void utils_copystring(const char *in, char **out){
+    int len = strlen(in) + 1;
+    *out = (char *) malloc (len);
+    strcpy(*out, in);
+}
--- a/source/tegraexplorer/utils/utils.h
+++ b/source/tegraexplorer/utils/utils.h
@@ -0,0 +1,4 @@
+#pragma once
+
+int utils_mmcMenu();
+void utils_copystring(const char *in, char **out);
Author	SHA1	Message	Date
Such Meme, Many Skill	d255dcf665	Cleanup	2020-03-19 23:01:30 +01:00
Such Meme, Many Skill	f1a4b05524	Bump version	2020-03-19 16:19:56 +01:00
Such Meme, Many Skill	d5c23ebf96	Reorder BIS menu options	2020-03-19 16:17:36 +01:00
Such Meme, Many Skill	4e1368faaf	Re-implement bis restoring	2020-03-19 16:11:18 +01:00
Such Meme, Many Skill	2d6411f60a	Add more general error codes & re-implement bis dumping	2020-03-19 13:00:42 +01:00
Such Meme, Many Skill	7191743f5d	Reorganise emmc.c/h and rename main menu c file	2020-03-19 00:11:18 +01:00
Such Meme, Many Skill	9d36f741d9	Day2 of restructuring/rewriting	2020-03-18 23:58:32 +01:00
Such Meme, Many Skill	ff618bc285	Move over script and tools	2020-03-18 12:18:39 +01:00
Such Meme, Many Skill	c60eb4b722	Fix compile error, oops	2020-03-18 00:58:23 +01:00
Such Meme, Many Skill	6aed4ad7b3	Start gfx rewrite & reorganize TE	2020-03-18 00:41:09 +01:00
Such Meme, Many Skill	761ceb7dbe	Misc changes	2020-03-17 00:26:35 +01:00
Such Meme, Many Skill	3f6d1b532c	(Attempt at) Implement restoring bis 1 switch was harmed in the making of this commit	2020-03-15 12:35:18 +01:00
Such Meme, Many Skill	144dc3a3f5	Implement bis dumping	2020-03-14 15:03:08 +01:00
Such Meme, Many Skill	5cb50722cf	[Scripting] Add CheckPath command	2020-03-11 21:01:57 +01:00
Such Meme, Many Skill	7c7dd7178f	Bump version	2020-03-06 12:26:54 +01:00
Such Meme, Many Skill	d93b50205a	Add battery indicator	2020-03-03 15:19:42 +01:00
Such Meme, Many Skill	405cb46b77	(Potentially) Fix file based emummc's not mounting	2020-02-22 19:49:25 +01:00
Such Meme, Many Skill	7f7c2e65ee	Fix freeing errors in copy-recursive	2020-02-22 19:05:50 +01:00
Such Meme, Many Skill	c2df3d80dd	Clean up main menu	2020-02-11 17:18:29 +01:00
Such Meme, Many Skill	a3b876ea3e	[Scripting] Add <VERSION>, <WAIT>, <COLOR> + cleanup + version bump	2020-02-10 14:16:17 +01:00
Such Meme, Many Skill	4309194a11	Bump version to 1.3.0	2020-02-07 23:07:12 +01:00
Such Meme, Many Skill	ae57cb1e63	Add MOVE command + add jank fatfs fix	2020-02-07 17:43:20 +01:00
Such Meme, Many Skill	a86294218c	Don't disable the emummc	2020-02-07 14:45:35 +01:00
Such Meme, Many Skill	eecefd634c	Add $EMUMMC$ flag, add DEL and DEL-R commands to scripting	2020-02-07 12:19:46 +01:00
Such Meme, Many Skill	37ce49a31f	Add $BTN$ flags to scripts	2020-02-07 00:55:55 +01:00
Such Meme, Many Skill	ab061cf0b3	Probably a good idea to not forget the forceExit	2020-02-06 23:50:06 +01:00
Such Meme, Many Skill	1a2fd158e9	Add scripting to TE	2020-02-06 23:31:19 +01:00
Such Meme, Many Skill	eb8652c6ec	Bug fixing round & add some emummc menus Notable bugs fixed: - pkg1id is now also used as foldername during fw dump - Clearing of screen in _recursive functions is no longer hardcoded - Folders get the correct file attributes - first 16 MiB of partition during partitioning gets cleared now	2020-01-30 23:53:27 +01:00
Such Meme, Many Skill	9885308bce	Add emummc support	2020-01-27 23:51:59 +01:00
Such Meme, Many Skill	1410fa185f	Fix partitioning mistake, bump version to 1.2.1	2020-01-08 14:21:53 +01:00
Such Meme, Many Skill	6724f364b5	Implement Tool for dumping User:/save + Finalize readme for release of 1.2.0	2020-01-07 21:53:02 +01:00
Such Meme, Many Skill	008d3ab494	Add file attributes to menus + fix a few misc things + bump version (readme isn't updated yet)	2020-01-07 15:28:23 +01:00
Such Meme, Many Skill	00bd1cd083	Split fs.c file + Misc changes to code in io.c	2020-01-06 18:42:57 +01:00
Such Meme, Many Skill	6af2bb63b8	Stop using an int to indicate dir size	2020-01-06 17:40:05 +01:00
Such Meme, Many Skill	02504c8a36	Make emmc writable + merge hekate fixes	2020-01-06 14:24:29 +01:00
Such Meme, Many Skill	ef76834ef4	Implement folder copy + Change error messaging internally + inproved recursive file deletion	2020-01-04 20:18:26 +01:00
Such Meme, Many Skill	6d75aa688c	(Attempt at) dynamic folder memory allocation	2020-01-04 13:20:28 +01:00
Such Meme, Many Skill	225a17116c	Fix memory leakage of getnextloc() and getprevloc()	2020-01-04 01:00:11 +01:00
Such Meme, Many Skill	e1f4c24686	Implement folder options (Delete folder)	2020-01-02 00:38:36 +01:00
suchmememanyskill	3e8cd67129	Add ko-fi link	2019-12-27 00:47:14 +01:00
Such Meme, Many Skill	697fc3a086	Do partition alignment, bump version to v1.1.1	2019-12-26 23:07:18 +01:00