@@ -115,7 +115,7 @@ void fw_reset_com(memory_chip_t *mc)

 			// copy User Settings 1 to User Settings 0 area

 			memcpy(&mc->data[0x3FE00], &mc->data[0x3FF00], 0x100);

-			printf("Firmware: save config");

+			fprintf(stderr, "Firmware: save config");

 			FILE *fp = fopen(mc->userfile, "wb");

 			if (fp)

 			{

@@ -124,15 +124,15 @@ void fw_reset_com(memory_chip_t *mc)

 					if (fwrite(&mc->data[0x0002A], 1, 0x1D6, fp) == 0x1D6) // WiFi Settings

 					{

 						if (fwrite(&mc->data[0x3FA00], 1, 0x300, fp) == 0x300)  // WiFi AP Settings

-							printf(" - done\n");

+							fprintf(stderr, " - done\n");

 						else

-							printf(" - failed\n");

+							fprintf(stderr, " - failed\n");

 					}

 				}

 				fclose(fp);

 			}

 			else

-				printf(" - failed\n");

+				fprintf(stderr, " - failed\n");

 		}

 		mc->write_enable = false;

@@ -235,7 +235,7 @@ uint8_t fw_transfer(memory_chip_t *mc, uint8_t data)

 				break;

 			default:

-				printf("Unhandled FW command: %02X\n", data);

+				fprintf(stderr, "Unhandled FW command: %02X\n", data);

 		}

 	}

@@ -468,7 +468,7 @@ bool BackupDevice::load_no_gba(const char *fname)

 		fseek(fsrc, 0, SEEK_END);

 		uint32_t fsize = ftell(fsrc);

 		fseek(fsrc, 0, SEEK_SET);

-		//printf("Open %s file (size %i bytes)\n", fname, fsize);

+		//fprintf(stderr, "Open %s file (size %i bytes)\n", fname, fsize);

 		auto in_buf = std::unique_ptr<uint8_t[]>(new uint8_t[fsize]);

@@ -480,18 +480,18 @@ bool BackupDevice::load_no_gba(const char *fname)

 			uint32_t size = 0;

 			if (!no_gba_unpackSAV(&in_buf[0], fsize, &out_buf[0], size))

 			{

-				//printf("New size %i byte(s)\n", size);

+				//fprintf(stderr, "New size %i byte(s)\n", size);

 				size = no_gba_savTrim(&out_buf[0], size);

-				//printf("--- new size after trim %i byte(s)\n", size);

+				//fprintf(stderr, "--- new size after trim %i byte(s)\n", size);

 				size = no_gba_fillLeft(size);

-				//printf("--- new size after fill %i byte(s)\n", size);

+				//fprintf(stderr, "--- new size after fill %i byte(s)\n", size);

 				raw_applyUserSettings(size);

 				this->data.resize(size);

 				for (uint32_t tt = 0; tt < size; ++tt)

 					this->data[tt] = out_buf[tt];

 				//dump back out as a dsv, just to keep things sane

-				printf("---- Loaded no$GBA save\n");

+				fprintf(stderr, "---- Loaded no$GBA save\n");

 				fclose(fsrc);

 				return true;

@@ -516,7 +516,7 @@ void BackupDevice::loadfile()

 	if (inf->fail())

 	{

 		// no dsv found; we need to try auto-importing a file with .sav extension

-		printf("DeSmuME .dsv save file not found. Trying to load an old raw .sav file.\n");

+		fprintf(stderr, "DeSmuME .dsv save file not found. Trying to load an old raw .sav file.\n");

 		// change extension to sav

 		char tmp[MAX_PATH];

@@ -527,7 +527,7 @@ void BackupDevice::loadfile()

 		inf.reset(new EMUFILE_FILE(tmp, "rb"));

 		if (inf->fail())

 		{

-			printf("Missing save file %s\n", this->filename.c_str());

+			fprintf(stderr, "Missing save file %s\n", this->filename.c_str());

 			return;

 		}

@@ -545,7 +545,7 @@ void BackupDevice::loadfile()

 		if (cmp)

 		{

 			// maybe it is a misnamed raw save file. try loading it that way

-			printf("Not a DeSmuME .dsv save file. Trying to load as raw.\n");

+			fprintf(stderr, "Not a DeSmuME .dsv save file. Trying to load as raw.\n");

 			if (!this->load_no_gba(this->filename.c_str()))

 				this->load_raw(this->filename.c_str());

 			return;

@@ -557,7 +557,7 @@ void BackupDevice::loadfile()

 		read32le(&version, inf.get());

 		if (version)

 		{

-			printf("Unknown save file format\n");

+			fprintf(stderr, "Unknown save file format\n");

 			return;

 		}

 		inf->fseek(-24, SEEK_CUR);

@@ -427,8 +427,6 @@ static int no_gba_unpackSAV(const uint8_t *in_buf, uint32_t fsize, uint8_t *out_

 			for (int t = 0; t < cc; ++t)

 				dst[dst_pos++] = src[src_pos++];

 		}

-		size = dst_pos;

-		return 0;

 	}

 	return 200;

 }

@@ -284,7 +284,7 @@ void BackupDevice::reset()

 		this->state = RUNNING;

 		int savetype = save_types[CommonSettings.manualBackupType].media_type;

 		int savesize = save_types[CommonSettings.manualBackupType].size;

-		this->ensure(static_cast<uint32_t>(savesize)); // expand properly if necessary

+		this->ensure(savesize); // expand properly if necessary

 		this->resize(savesize); // truncate if necessary

 		this->addr_size = this->addr_size_for_old_save_type(savetype);

 	}

@@ -356,12 +356,12 @@ void BackupDevice::load_old_state(uint32_t addrSize, uint8_t *Data, uint32_t dat

 // =======================================================================

 // =======================================================================

-static int no_gba_unpackSAV(void *in_buf, uint32_t fsize, void *out_buf, uint32_t &size)

+static int no_gba_unpackSAV(const uint8_t *in_buf, uint32_t fsize, uint8_t *out_buf, uint32_t &size)

 {

 	const char no_GBA_HEADER_ID[] = "NocashGbaBackupMediaSavDataFile";

 	const char no_GBA_HEADER_SRAM_ID[] = "SRAM";

-	uint8_t *src = static_cast<uint8_t *>(in_buf);

-	uint8_t *dst = static_cast<uint8_t *>(out_buf);

+	const uint8_t *src = in_buf;

+	uint8_t *dst = out_buf;

 	uint32_t src_pos = 0;

 	uint32_t dst_pos = 0;

 	uint32_t size_unpacked = 0;

@@ -379,11 +379,11 @@ static int no_gba_unpackSAV(void *in_buf, uint32_t fsize, void *out_buf, uint32_

 		if (src[i + 0x40] != no_GBA_HEADER_SRAM_ID[i])

 			return 2;

-	compressMethod = *(reinterpret_cast<uint32_t *>(src + 0x44));

+	compressMethod = *(reinterpret_cast<const uint32_t *>(src + 0x44));

 	if (!compressMethod) // unpacked

 	{

-		size_unpacked = *(reinterpret_cast<uint32_t *>(src + 0x48));

+		size_unpacked = *(reinterpret_cast<const uint32_t *>(src + 0x48));

 		src_pos = 0x4C;

 		for (uint32_t i = 0; i < size_unpacked; ++i)

 			dst[dst_pos++] = src[src_pos++];

@@ -393,7 +393,7 @@ static int no_gba_unpackSAV(void *in_buf, uint32_t fsize, void *out_buf, uint32_

 	if (compressMethod == 1) // packed (method 1)

 	{

-		size_unpacked = *(reinterpret_cast<uint32_t *>(src + 0x4C));

+		size_unpacked = *(reinterpret_cast<const uint32_t *>(src + 0x4C));

 		src_pos = 0x50;

 		while (true)

@@ -408,7 +408,7 @@ static int no_gba_unpackSAV(void *in_buf, uint32_t fsize, void *out_buf, uint32_

 			if (cc == 0x80)

 			{

-				uint16_t tsize = *(reinterpret_cast<uint16_t *>(src + src_pos + 1));

+				uint16_t tsize = *(reinterpret_cast<const uint16_t *>(src + src_pos + 1));

 				for (int t = 0; t < tsize; ++t)

 					dst[dst_pos++] = src[src_pos];

 				src_pos += 3;

@@ -433,11 +433,11 @@ static int no_gba_unpackSAV(void *in_buf, uint32_t fsize, void *out_buf, uint32_

 	return 200;

 }

-static uint32_t no_gba_savTrim(void *buf, uint32_t size)

+static uint32_t no_gba_savTrim(uint8_t *buf, uint32_t size)

 {

 	uint32_t rows = size / 16;

 	uint32_t pos = (size - 16);

-	uint8_t *src = static_cast<uint8_t *>(buf);

+	uint8_t *src = buf;

 	for (unsigned i = 0; i < rows; ++i, pos -= 16)

 	{

@@ -539,7 +539,7 @@ void BackupDevice::loadfile()

 	else

 	{

 		// scan for desmume save footer

-		int32_t cookieLen = static_cast<int32_t>(strlen(kDesmumeSaveCookie));

+		int32_t cookieLen = strlen(kDesmumeSaveCookie);

 		auto sigbuf = std::unique_ptr<char[]>(new char[cookieLen]);

 		inf->fseek(-cookieLen, SEEK_END);

 		inf->fread(&sigbuf[0], cookieLen);

@@ -610,7 +610,7 @@ bool BackupDevice::load_raw(const char *fn, uint32_t force_size)

 		return false;

 	fseek(inf, 0, SEEK_END);

-	uint32_t size = static_cast<uint32_t>(ftell(inf));

+	uint32_t size = ftell(inf);

 	uint32_t left = 0;

 	if (force_size > 0)

@@ -1,7 +1,7 @@

 /*

 	Copyright (C) 2006 thoduv

 	Copyright (C) 2006-2007 Theo Berkau

-	Copyright (C) 2008-2012 DeSmuME team

+	Copyright (C) 2008-2013 DeSmuME team

 	This file is free software: you can redistribute it and/or modify

 	it under the terms of the GNU General Public License as published by

@@ -19,167 +19,90 @@

 #include <cstdlib>

 #include <cstring>

-

-//#include "debug.h"

 #include "types.h"

 #include "mc.h"

-//#include "movie.h"

 #include "readwrite.h"

 #include "NDSSystem.h"

-#define FW_CMD_READ             0x03

-#define FW_CMD_WRITEDISABLE     0x04

-#define FW_CMD_READSTATUS       0x05

-#define FW_CMD_WRITEENABLE      0x06

-#define FW_CMD_PAGEWRITE        0x0A

-#define FW_CMD_READ_ID			0x9F

-

-#define BM_CMD_AUTODETECT       0xFF

-#define BM_CMD_WRITESTATUS      0x01

-#define BM_CMD_WRITELOW         0x02

-#define BM_CMD_READLOW          0x03

-#define BM_CMD_WRITEDISABLE     0x04

-#define BM_CMD_READSTATUS       0x05

-#define BM_CMD_WRITEENABLE      0x06

-#define BM_CMD_WRITEHIGH        0x0A

-#define BM_CMD_READHIGH         0x0B

-

-/* FLASH*/

-#define COMM_PAGE_WRITE		0x0A

-#define COMM_PAGE_ERASE		0xDB

-#define COMM_SECTOR_ERASE	0xD8

-#define COMM_CHIP_ERASE		0xC7

-#define CARDFLASH_READ_BYTES_FAST	0x0B    /* Not used*/

-#define CARDFLASH_DEEP_POWDOWN		0xB9    /* Not used*/

-#define CARDFLASH_WAKEUP			0xAB    /* Not used*/

-

-//since r2203 this was 0x00.

-//but baby pals proves finally that it should be 0xFF:

-//the game reads its initial sound volumes from uninitialized data, and if it is 0, the game will be silent

-//if it is 0xFF then the game starts with its sound and music at max, as presumably it is supposed to.

-//so in r3303 I finally changed it (no$ appears definitely to initialized to 0xFF)

+static const uint8_t FW_CMD_READ = 0x03;

+static const uint8_t FW_CMD_WRITEDISABLE = 0x04;

+static const uint8_t FW_CMD_READSTATUS = 0x05;

+static const uint8_t FW_CMD_WRITEENABLE = 0x06;

+static const uint8_t FW_CMD_PAGEWRITE = 0x0A;

+static const uint8_t FW_CMD_READ_ID = 0x9F;

+

+// since r2203 this was 0x00.

+// but baby pals proves finally that it should be 0xFF:

+// the game reads its initial sound volumes from uninitialized data, and if it is 0, the game will be silent

+// if it is 0xFF then the game starts with its sound and music at max, as presumably it is supposed to.

+// so in r3303 I finally changed it (no$ appears definitely to initialized to 0xFF)

 static const uint8_t kUninitializedSaveDataValue = 0xFF;

-static const char* kDesmumeSaveCookie = "|-DESMUME SAVE-|";

-

-static const uint32_t saveSizes[] = {512,			// 4k

-								8*1024,			// 64k

-								32*1024,		// 512k

-								64*1024,		// 1Mbit

-								256*1024,		// 2Mbit

-								512*1024,		// 4Mbit

-								1024*1024,		// 8Mbit

-								2048*1024,		// 16Mbit

-								4096*1024,		// 32Mbit

-								8192*1024,		// 64Mbit

-								16384*1024,		// 128Mbit

-								32768*1024,		// 256Mbit

-								65536*1024,		// 512Mbit

-								0xFFFFFFFF};

-static const uint32_t saveSizes_count = ARRAY_SIZE(saveSizes);

+static const char *kDesmumeSaveCookie = "|-DESMUME SAVE-|";

 //the lookup table from user save types to save parameters

-const int save_types[][2] = {

-        {MC_TYPE_AUTODETECT,1},

-        {MC_TYPE_EEPROM1,MC_SIZE_4KBITS},

-        {MC_TYPE_EEPROM2,MC_SIZE_64KBITS},

-        {MC_TYPE_EEPROM2,MC_SIZE_512KBITS},

-        {MC_TYPE_FRAM,MC_SIZE_256KBITS},

-        {MC_TYPE_FLASH,MC_SIZE_2MBITS},

-		{MC_TYPE_FLASH,MC_SIZE_4MBITS},

-		{MC_TYPE_FLASH,MC_SIZE_8MBITS},

-		{MC_TYPE_FLASH,MC_SIZE_16MBITS},

-		{MC_TYPE_FLASH,MC_SIZE_32MBITS},

-		{MC_TYPE_FLASH,MC_SIZE_64MBITS},

-		{MC_TYPE_FLASH,MC_SIZE_128MBITS},

-		{MC_TYPE_FLASH,MC_SIZE_256MBITS},

-		{MC_TYPE_FLASH,MC_SIZE_512MBITS}

+const SAVE_TYPE save_types[] =

+{

+	{"Autodetect", MC_TYPE_AUTODETECT, 1},

+	{"EEPROM 4kbit", MC_TYPE_EEPROM1, MC_SIZE_4KBITS},

+	{"EEPROM 64kbit", MC_TYPE_EEPROM2, MC_SIZE_64KBITS},

+	{"EEPROM 512kbit", MC_TYPE_EEPROM2, MC_SIZE_512KBITS},

+	{"FRAM 256kbit", MC_TYPE_FRAM, MC_SIZE_256KBITS},

+	{"FLASH 2Mbit", MC_TYPE_FLASH, MC_SIZE_2MBITS},

+	{"FLASH 4Mbit", MC_TYPE_FLASH, MC_SIZE_4MBITS},

+	{"FLASH 8Mbit", MC_TYPE_FLASH, MC_SIZE_8MBITS},

+	{"FLASH 16Mbit", MC_TYPE_FLASH, MC_SIZE_16MBITS},

+	{"FLASH 32Mbit", MC_TYPE_FLASH, MC_SIZE_32MBITS},

+	{"FLASH 64Mbit", MC_TYPE_FLASH, MC_SIZE_64MBITS},

+	{"FLASH 128Mbit", MC_TYPE_FLASH, MC_SIZE_128MBITS},

+	{"FLASH 256Mbit", MC_TYPE_FLASH, MC_SIZE_256MBITS},

+	{"FLASH 512Mbit", MC_TYPE_FLASH, MC_SIZE_512MBITS}

 };

-

-/*const char *save_names[] = {

-		"EEPROM 4kbit",

-		"EEPROM 64kbit",

-		"EEPROM 512kbit",

-		"FRAM 256kbit",

-		"FLASH 2Mbit",

-		"FLASH 4Mbit",

-		"FLASH 8Mbit",

-		"FLASH 16Mbit",

-		"FLASH 32Mbit",

-		"FLASH 64Mbit",

-		"FLASH 128Mbit",

-		"FLASH 256Mbit",

-		"FLASH 512Mbit"

-};*/

-

-//forces the currently selected backup type to be current

-//(can possibly be used to repair poorly chosen save types discovered late in gameplay i.e. pokemon gamers)

-/*void backup_forceManualBackupType()

-{

-	MMU_new.backupDevice.forceManualBackupType();

-}*/

-

-/*void backup_setManualBackupType(int type)

-{

-	CommonSettings.manualBackupType = type;

-}*/

-

 void mc_init(memory_chip_t *mc, int type)

 {

-        mc->com = 0;

-        mc->addr = 0;

-        mc->addr_shift = 0;

-        mc->data.clear();

-        mc->size = 0;

-        mc->write_enable = false;

-        mc->writeable_buffer = false;

-        mc->type = type;

-        mc->autodetectsize = 0;

-

-        switch(mc->type)

-        {

-           case MC_TYPE_EEPROM1:

-              mc->addr_size = 1;

-              break;

-           case MC_TYPE_EEPROM2:

-           case MC_TYPE_FRAM:

-              mc->addr_size = 2;

-              break;

-           case MC_TYPE_FLASH:

-              mc->addr_size = 3;

-              break;

-           default: break;

-        }

+	mc->com = 0;

+	mc->addr = 0;

+	mc->addr_shift = 0;

+	mc->data.clear();

+	mc->size = 0;

+	mc->write_enable = false;

+	mc->writeable_buffer = false;

+	mc->type = type;

+	mc->autodetectsize = 0;

+

+	switch (mc->type)

+	{

+		case MC_TYPE_EEPROM1:

+			mc->addr_size = 1;

+			break;

+		case MC_TYPE_EEPROM2:

+		case MC_TYPE_FRAM:

+			mc->addr_size = 2;

+			break;

+		case MC_TYPE_FLASH:

+			mc->addr_size = 3;

+	}

 }

 uint8_t *mc_alloc(memory_chip_t *mc, uint32_t size)

 {

-	/*uint8_t *buffer;

-	buffer = new uint8_t[size];

-	memset(buffer,0,size);*/

-

-	//if (mc->data) delete [] mc->data;

 	mc->data.clear();

-	//mc->data = buffer;

-	//if(!buffer) { return NULL; }

 	mc->data.resize(size, 0);

 	mc->size = size;

 	mc->writeable_buffer = true;

-	//return buffer;

-	return NULL;

+	return nullptr;

 }

 void mc_free(memory_chip_t *mc)

 {

-    //if(mc->data) delete[] mc->data;

 	mc->data.clear();

-    mc_init(mc, 0);

+	mc_init(mc, 0);

 }

 void fw_reset_com(memory_chip_t *mc)

 {

-	if(mc->com == FW_CMD_PAGEWRITE)

+	if (mc->com == FW_CMD_PAGEWRITE)

 	{

 		if (mc->fp)

 		{

@@ -196,9 +119,9 @@ void fw_reset_com(memory_chip_t *mc)

 			FILE *fp = fopen(mc->userfile, "wb");

 			if (fp)

 			{

-				if (fwrite(&mc->data[0x3FF00], 1, 0x100, fp) == 0x100)		// User Settings

+				if (fwrite(&mc->data[0x3FF00], 1, 0x100, fp) == 0x100) // User Settings

 				{

-					if (fwrite(&mc->data[0x0002A], 1, 0x1D6, fp) == 0x1D6)  // WiFi Settings

+					if (fwrite(&mc->data[0x0002A], 1, 0x1D6, fp) == 0x1D6) // WiFi Settings

 					{

 						if (fwrite(&mc->data[0x3FA00], 1, 0x300, fp) == 0x300)  // WiFi AP Settings

 							printf(" - done\n");

@@ -220,478 +143,173 @@ void fw_reset_com(memory_chip_t *mc)

 uint8_t fw_transfer(memory_chip_t *mc, uint8_t data)

 {

-	if(mc->com == FW_CMD_READ || mc->com == FW_CMD_PAGEWRITE) /* check if we are in a command that needs 3 bytes address */

+	if (mc->com == FW_CMD_READ || mc->com == FW_CMD_PAGEWRITE) /* check if we are in a command that needs 3 bytes address */

 	{

-		if(mc->addr_shift > 0)   /* if we got a complete address */

+		if (mc->addr_shift > 0) /* if we got a complete address */

 		{

-			mc->addr_shift--;

+			--mc->addr_shift;

 			mc->addr |= data << (mc->addr_shift * 8); /* argument is a byte of address */

 		}

-		else    /* if we have received 3 bytes of address, proceed command */

+		else /* if we have received 3 bytes of address, proceed command */

 		{

-			switch(mc->com)

+			switch (mc->com)

 			{

 				case FW_CMD_READ:

-					if(mc->addr < mc->size)  /* check if we can read */

+					if (mc->addr < mc->size)  /* check if we can read */

 					{

-						data = mc->data[mc->addr];       /* return byte */

-						mc->addr++;      /* then increment address */

+						data = mc->data[mc->addr]; /* return byte */

+						++mc->addr; /* then increment address */

 					}

 					break;

-

 				case FW_CMD_PAGEWRITE:

-					if(mc->addr < mc->size)

+					if (mc->addr < mc->size)

 					{

-						mc->data[mc->addr] = data;       /* write byte */

-						mc->addr++;

+						mc->data[mc->addr] = data; /* write byte */

+						++mc->addr;

 					}

-					break;

 			}

-

 		}

 	}

-	else if(mc->com == FW_CMD_READ_ID)

+	else if (mc->com == FW_CMD_READ_ID)

 	{

-		switch(mc->addr)

+		switch (mc->addr)

 		{

-		//here is an ID string measured from an old ds fat: 62 16 00 (0x62=sanyo)

-		//but we chose to use an ST from martin's ds fat string so programs might have a clue as to the firmware size:

-		//20 40 12

-		case 0:

-			data = 0x20;

-			mc->addr=1;

-			break;

-		case 1:

-			data = 0x40; //according to gbatek this is the device ID for the flash on someone's ds fat

-			mc->addr=2;

-			break;

-		case 2:

-			data = 0x12;

-			mc->addr = 0;

-			break;

+			// here is an ID string measured from an old ds fat: 62 16 00 (0x62=sanyo)

+			// but we chose to use an ST from martin's ds fat string so programs might have a clue as to the firmware size:

+			// 20 40 12

+			case 0:

+				data = 0x20;

+				mc->addr = 1;

+				break;

+			case 1:

+				data = 0x40; // according to gbatek this is the device ID for the flash on someone's ds fat

+				mc->addr = 2;

+				break;

+			case 2:

+				data = 0x12;

+				mc->addr = 0;

 		}

 	}

-	else if(mc->com == FW_CMD_READSTATUS)

-	{

+	else if (mc->com == FW_CMD_READSTATUS)

 		return mc->write_enable ? 0x02 : 0x00;

-	}

-	else	//finally, check if it's a new command

+	else // finally, check if it's a new command

 	{

-		switch(data)

+		switch (data)

 		{

-			case 0: break;	//nothing

+			case 0:

+				break; // nothing

 			case FW_CMD_READ_ID:

 				mc->addr = 0;

 				mc->com = FW_CMD_READ_ID;

 				break;

-			case FW_CMD_READ:    //read command

+			case FW_CMD_READ: //read command

 				mc->addr = 0;

 				mc->addr_shift = 3;

 				mc->com = FW_CMD_READ;

 				break;

-			case FW_CMD_WRITEENABLE:     //enable writing

-				if(mc->writeable_buffer) { mc->write_enable = true; }

+			case FW_CMD_WRITEENABLE: //enable writing

+				if (mc->writeable_buffer)

+					mc->write_enable = true;

 				break;

-			case FW_CMD_WRITEDISABLE:    //disable writing

-

+			case FW_CMD_WRITEDISABLE: //disable writing

 				mc->write_enable = false;

 				break;

-			case FW_CMD_PAGEWRITE:       //write command

-				if(mc->write_enable)

+			case FW_CMD_PAGEWRITE: //write command

+				if (mc->write_enable)

 				{

 					mc->addr = 0;

 					mc->addr_shift = 3;

 					mc->com = FW_CMD_PAGEWRITE;

 				}

-				else { data = 0; }

+				else

+					data = 0;

 				break;

-			case FW_CMD_READSTATUS:  //status register command

+			case FW_CMD_READSTATUS: //status register command

 				mc->com = FW_CMD_READSTATUS;

 				break;

 			default:

 				printf("Unhandled FW command: %02X\n", data);

-				break;

 		}

 	}

 	return data;

 }

-/*bool BackupDevice::save_state(EMUFILE* os)

-{

-	uint32_t version = 2;

-	//v0

-	write32le(version,os);

-	write32le(write_enable,os);

-	write32le(com,os);

-	write32le(addr_size,os);

-	write32le(addr_counter,os);

-	write32le((uint32_t)state,os);

-	writebuffer(data,os);

-	writebuffer(data_autodetect,os);

-	//v1

-	write32le(addr,os);

-	//v2

-	write8le(motionInitState,os);

-	write8le(motionFlag,os);

-	return true;

-}*/

-

-bool BackupDevice::load_state(EMUFILE* is)

-{

-	uint32_t version;

-	if(read32le(&version,is)!=1) return false;

-	//if(version>=0)

-	{

-		readbool(&write_enable,is);

-		read32le(&com,is);

-		read32le(&addr_size,is);

-		read32le(&addr_counter,is);

-		uint32_t temp;

-		read32le(&temp,is);

-		state = (STATE)temp;

-		readbuffer(data,is);

-		readbuffer(data_autodetect,is);

-	}

-	if(version>=1)

-		read32le(&addr,is);

-	if(version>=2)

-	{

-		read8le(&motionInitState,is);

-		read8le(&motionFlag,is);

-	}

-

-	return true;

-}

-

 BackupDevice::BackupDevice()

 {

-	//isMovieMode = false;

-	reset();

+	this->reset();

 }

-//due to unfortunate shortcomings in the emulator architecture,

-//at reset-time, we won't have a filename to the .dsv file.

-//so the only difference between load_rom (init) and reset is that

-//one of them saves the filename

-void BackupDevice::load_rom(const char* fn)

+// due to unfortunate shortcomings in the emulator architecture,

+// at reset-time, we won't have a filename to the .dsv file.

+// so the only difference between load_rom (init) and reset is that

+// one of them saves the filename

+void BackupDevice::load_rom(const std::string &fn)

 {

-	//isMovieMode = false;

 	this->filename = fn;

-	reset();

+	this->reset();

 }

-/*void BackupDevice::movie_mode()

-{

-	isMovieMode = true;

-	reset();

-}*/

-

 void BackupDevice::reset_hardware()

 {

-	write_enable = false;

-	com = 0;

-	addr = addr_counter = 0;

-	motionInitState = MOTION_INIT_STATE_IDLE;

-	motionFlag = MOTION_FLAG_NONE;

-	state = DETECTING;

-	flushPending = false;

-	lazyFlushPending = false;

+	this->write_enable = false;

+	this->com = 0;

+	this->addr = this->addr_counter = 0;

+	this->motionInitState = MOTION_INIT_STATE_IDLE;

+	this->motionFlag = MOTION_FLAG_NONE;

+	this->state = DETECTING;

+	this->flushPending = false;

+	this->lazyFlushPending = false;

 }

 void BackupDevice::reset()

 {

-	memset(&info, 0, sizeof(info));

-	reset_hardware();

-	resize(0);

-	data_autodetect.resize(0);

-	addr_size = 0;

-	loadfile();

-

-	//if the user has requested a manual choice for backup type, and we havent imported a raw save file, then apply it now

-	if(state == DETECTING && CommonSettings.manualBackupType != MC_TYPE_AUTODETECT)

-	{

-		state = RUNNING;

-		int savetype = save_types[CommonSettings.manualBackupType][0];

-		int savesize = save_types[CommonSettings.manualBackupType][1];

-		ensure((uint32_t)savesize); //expand properly if necessary

-		resize(savesize); //truncate if necessary

-		addr_size = addr_size_for_old_save_type(savetype);

-		//flush();

-	}

-}

-

-/*void BackupDevice::close_rom()

-{

-	//flush();

-}*/

+	memset(&this->info, 0, sizeof(this->info));

+	this->reset_hardware();

+	this->resize(0);

+	this->data_autodetect.resize(0);

+	this->addr_size = 0;

+	this->loadfile();

-/*void BackupDevice::reset_command()

-{

-	//printf("MC RESET\n");

-	//for a performance hack, save files are only flushed after each reset command

-	//(hopefully, after each page)

-	if(flushPending)

-	{

-		//flush();

-		flushPending = false;

-		lazyFlushPending = false;

-	}

-

-	if(state == DETECTING && data_autodetect.size()>0)

+	// if the user has requested a manual choice for backup type, and we havent imported a raw save file, then apply it now

+	if (this->state == DETECTING && CommonSettings.manualBackupType != MC_TYPE_AUTODETECT)

 	{

-		//we can now safely detect the save address size

-		uint32_t autodetect_size = data_autodetect.size();

-

-		printf("Autodetecting with autodetect_size=%d\n",autodetect_size);

-

-		const uint8_t sm64_sig[] = {0x01,0x80,0x00,0x00};

-		if(autodetect_size == 4 && !memcmp(&data_autodetect[0],sm64_sig,4))

-		{

-			addr_size = 2;

-		}

-		else //detect based on rules

-			switch(autodetect_size)

-			{

-			case 0:

-			case 1:

-				printf("Catastrophic error while autodetecting save type.\nIt will need to be specified manually\n");

-				#ifdef _WINDOWS

-				MessageBoxA(0,"Catastrophic Error Code: Camel;\nyour save type has not been autodetected correctly;\nplease report to developers",0,0);

-				#endif

-				addr_size = 1; //choose 1 just to keep the busted savefile from growing too big

-				break;

-			case 2:

-				 //the modern typical case for small eeproms

-				addr_size = 1;

-				break;

-			case 3:

-				//another modern typical case..

-				//but unfortunately we select this case for spider-man 3, when what it meant to do was

-				//present the archaic 1+2 case

-				//it seems that over the hedge does this also.

-				addr_size = 2;

-				break;

-			case 4:

-				//a modern typical case

-				addr_size = 3;

-				break;

-			default:

-				//the archaic case: write the address and then some modulo-4 number of bytes

-				//why modulo 4? who knows.

-				addr_size = autodetect_size & 3;

-				break;

-			}

-

-		state = RUNNING;

-		data_autodetect.resize(0);

-		//flush();

-	}

-

-	com = 0;

-}*/

-/*uint8_t BackupDevice::data_command(uint8_t val, int cpu)

-{

-	//printf("MC CMD: %02X\n",val);

-

-	//motion: some guessing here... hope it doesn't break anything

-	if(com == BM_CMD_READLOW && motionInitState == MOTION_INIT_STATE_RECEIVED_4_B && val == 0)

-	{

-		motionInitState = MOTION_INIT_STATE_IDLE;

-		motionFlag |= MOTION_FLAG_ENABLED;

-		//return 0x04; //return 0x04 to enable motion!!!!!

-		return 0; //but we return 0 to disable it! since we don't emulate it anyway

-	}

-

-	//if the game firmly believes we have motion support, then ignore all motion commands, since theyre not emulated.

-	if(motionFlag & MOTION_FLAG_SENSORMODE)

-	{

-		return 0;

-	}

-

-	if(com == BM_CMD_READLOW || com == BM_CMD_WRITELOW)

-	{

-		//handle data or address

-		if(state == DETECTING)

-		{

-			if(com == BM_CMD_WRITELOW)

-			{

-				printf("Unexpected backup device initialization sequence using writes!\n");

-			}

-

-			//just buffer the data until we're no longer detecting

-			data_autodetect.push_back(val);

-			val = 0;

-		}

-		else

-		{

-			if(addr_counter<addr_size)

-			{

-				//continue building address

-				addr <<= 8;

-				addr |= val;

-				addr_counter++;

-				//if(addr_counter==addr_size) printf("ADR: %08X\n",addr);

-			}

-			else

-			{

-				//why does tomb raider underworld access 0x180 and go clear through to 0x280?

-				//should this wrap around at 0 or at 0x100?

-				if(addr_size == 1) addr &= 0x1FF;

-

-				//address is complete

-				ensure(addr+1);

-				if(com == BM_CMD_READLOW)

-				{

-					//printf("READ ADR: %08X\n",addr);

-					val = data[addr];

-					//flushPending = true; //is this a good idea? it may slow stuff down, but it is helpful for debugging

-					lazyFlushPending = true; //lets do this instead

-					//printf("read: %08X\n",addr);

-				}

-				else

-				{

-					if(write_enable)

-					{

-						//printf("WRITE ADR: %08X\n",addr);

-						data[addr] = val;

-						flushPending = true;

-						//printf("writ: %08X\n",addr);

-					}

-				}

-				addr++;

-

-			}

-		}

-	}

-	else if(com == BM_CMD_READSTATUS)

-	{

-		//handle request to read status

-		//LOG("Backup Memory Read Status: %02X\n", write_enable << 1);

-		return (write_enable << 1) | (3<<2);

-	}

-	else

-	{

-		//there is no current command. receive one

-		switch(val)

-		{

-			case 0: break; //??

-

-			case 0xFE:

-				if(motionInitState == MOTION_INIT_STATE_IDLE) { motionInitState = MOTION_INIT_STATE_FE; return 0; }