From 93df29017249b12d07eb4bedfea756143e7a84f8 Mon Sep 17 00:00:00 2001
From: FIX94 <fix94.1@gmail.com>
Date: Sat, 9 Dec 2017 16:43:02 +0100
Subject: [PATCH] -added support for mappers 32, 49, 60, 65, 73 and 156 -added
 soft reset keyboard command ctrl+r

---
 README.md        |   3 +-
 cpu.c            |   6 ++
 cpu.h            |   1 +
 main.c           |  22 +++++-
 mapper.c         |   1 +
 mapper/m156.c    | 167 +++++++++++++++++++++++++++++++++++++++++
 mapper/m32.c     | 176 +++++++++++++++++++++++++++++++++++++++++++
 mapper/m4add.c   |  81 ++++++++++++++++++++
 mapper/m65.c     | 192 +++++++++++++++++++++++++++++++++++++++++++++++
 mapper/p16c8.c   |  73 ++++++++++++++++++
 mapper/s5b.c     |   8 +-
 mapper/vrc3.c    | 149 ++++++++++++++++++++++++++++++++++++
 mapperList.c     |  18 +++--
 mapper_h/m156.h  |  19 +++++
 mapper_h/m32.h   |  19 +++++
 mapper_h/m4add.h |   5 ++
 mapper_h/m65.h   |  20 +++++
 mapper_h/p16c8.h |   7 ++
 mapper_h/vrc3.h  |  20 +++++
 19 files changed, 971 insertions(+), 16 deletions(-)
 create mode 100644 mapper/m156.c
 create mode 100644 mapper/m32.c
 create mode 100644 mapper/m65.c
 create mode 100644 mapper/vrc3.c
 create mode 100644 mapper_h/m156.h
 create mode 100644 mapper_h/m32.h
 create mode 100644 mapper_h/m65.h
 create mode 100644 mapper_h/vrc3.h

diff --git a/README.md b/README.md
index f232a6c..5e15527 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ If you want to check it out for some reason I do include a windows binary in the
 You will need freeglut as well as openal-soft to compile the project, it should run on most systems since it is fairly generic C code.  
 NTSC and PAL .nes ROMs are supported right now, it also creates .sav files if the chosen game supports saving.  
 Supported Mappers:  
-0,1,2,3,4,5,7,9,10,11,12,13,15,19,21,22,23,24,25,26,33,34,36,37,38,41,44,45,46,47,48,52,57,58,61,62,66,67,68,69,70,71,75,76,78,79,85,87,88,89,93,94,95,97,99,101,112,113,118,119,133,140,144,145,146,147,148,149,152,154,174,180,184,185,200,201,202,203,205,206,210,212,225,226,228,232,232,240 and 242.  
+0,1,2,3,4,5,7,9,10,11,12,13,15,19,21,22,23,24,25,26,32,33,34,36,37,38,41,44,45,46,47,48,49,52,57,58,60,61,62,65,66,67,68,69,70,71,73,75,76,78,79,85,87,88,89,93,94,95,97,99,101,112,113,118,119,133,140,144,145,146,147,148,149,152,154,155,156,174,180,184,185,200,201,202,203,205,206,210,212,225,226,228,232,232,240 and 242.  
 Supported Audio Expansions:  
 VRC6, VRC7, FDS, MMC5, N163, Sunsoft 5B  
 Normal .nes files are supported, if you are starting a PAL NES title then make sure it has (E),(Europe),(Australia),(France),(Germany),(Italy),(Spain) or (Sweden) in the filename to be started in PAL mode.  
@@ -21,6 +21,7 @@ S is select
 Arrow Keys is DPad  
 Keys 1-9 integer-scale the window to number  
 P is Pause  
+Ctrl+R is Soft Reset
 B is Disk Switching (for FDS)  
 O is Enable/Disable vertical Overscan  
 If you really want controller support and you are on windows, go grab joy2key, it works just fine with fixNES (and fixGB).    
diff --git a/cpu.c b/cpu.c
index b07f8dc..a63aa81 100644
--- a/cpu.c
+++ b/cpu.c
@@ -835,6 +835,7 @@ static bool cpuHandleIrqUpdates()
 	//handle incoming IRQs
 	if(reset)
 	{
+		apuSet8(0x15, 0);
 		cpu_action_arr = cpu_reset_arr;
 		cpu_arr_pos = 0;
 		cpu_action_func = cpuNoAction;
@@ -1502,3 +1503,8 @@ void cpuInitNSF(uint16_t addr, uint8_t newA, uint8_t newX)
 	nsf_endPlayback = false;
 	//printf("Init at %04x\n", addr);
 }
+
+void cpuSoftReset()
+{
+	reset = true;
+}
diff --git a/cpu.h b/cpu.h
index ee530f6..11d131d 100644
--- a/cpu.h
+++ b/cpu.h
@@ -13,6 +13,7 @@ void cpuSetupActionArr();
 void cpuInitNSF(uint16_t addr, uint8_t newA, uint8_t newX);
 void cpuStartPlayNSF();
 void cpuEndPlayNSF();
+void cpuSoftReset();
 bool cpuCycle();
 void cpuIncWaitCycles(uint32_t inc);
 uint16_t cpuGetPc();
diff --git a/main.c b/main.c
index 95f6678..424c08f 100644
--- a/main.c
+++ b/main.c
@@ -35,7 +35,7 @@
 #define DEBUG_KEY 0
 #define DEBUG_LOAD_INFO 1
 
-static const char *VERSION_STRING = "fixNES Alpha v1.0.3";
+static const char *VERSION_STRING = "fixNES Alpha v1.0.4";
 static char window_title[256];
 static char window_title_pause[256];
 
@@ -82,6 +82,7 @@ static bool inPause = false;
 static bool inOverscanToggle = false;
 static bool inResize = false;
 static bool inDiskSwitch = false;
+static bool inReset = false;
 
 #if WINDOWS_BUILD
 #include <windows.h>
@@ -118,6 +119,8 @@ static uint16_t cpuCycleTimer;
 extern uint8_t inValReads[8];
 //from mapper.c
 extern bool mapperUse78A;
+//from m32.c
+extern bool m32_singlescreen;
 
 int main(int argc, char** argv)
 {
@@ -184,6 +187,13 @@ int main(int argc, char** argv)
 		printf("Used Mapper: %i\n", mapper);
 		printf("PRG: 0x%x bytes PRG RAM: 0x%x bytes CHR: 0x%x bytes\n", prgROMsize, emuPrgRAMsize, chrROMsize);
 		#endif
+		if(mapper == 32)
+		{
+			if(strstr(emuFileName,"Major League") != NULL)
+				m32_singlescreen = true;
+			else
+				m32_singlescreen = false;
+		}
 		if(mapper == 78)
 		{
 			if(strstr(emuFileName,"Holy Diver") != NULL)
@@ -902,6 +912,13 @@ static void nesEmuHandleKeyDown(unsigned char key, int x, int y)
 				doOverscan ^= true;
 			}
 			break;
+		case '\x12': //ctrl-R
+			if(!inReset)
+			{
+				inReset = true;
+				if(!nesEmuNSFPlayback)
+					cpuSoftReset();
+			}
 		default:
 			break;
 	}
@@ -971,6 +988,9 @@ static void nesEmuHandleKeyUp(unsigned char key, int x, int y)
 		case 'O':
 			inOverscanToggle = false;
 			break;
+		case '\x12': //ctrl-R
+			inReset = false;
+			break;
 		default:
 			break;
 	}
diff --git a/mapper.c b/mapper.c
index 9f92cf8..acd8749 100644
--- a/mapper.c
+++ b/mapper.c
@@ -12,6 +12,7 @@
 #include "mapperList.h"
 #include "mapper_h/nsf.h"
 #include "mapper_h/fds.h"
+#include "mapper_h/m32.h"
 #include "mapper_h/p16c8.h"
 #include "ppu.h"
 
diff --git a/mapper/m156.c b/mapper/m156.c
new file mode 100644
index 0000000..38726c0
--- /dev/null
+++ b/mapper/m156.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2017 FIX94
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <string.h>
+#include "../ppu.h"
+#include "../mapper.h"
+
+static uint8_t *m156_prgROM;
+static uint8_t *m156_prgRAM;
+static uint8_t *m156_chrROM;
+static uint32_t m156_prgROMsize;
+static uint32_t m156_prgRAMsize;
+static uint32_t m156_chrROMsize;
+static uint32_t m156_prgROMand;
+static uint32_t m156_prgRAMand;
+static uint32_t m156_chrROMand;
+static uint32_t m156_curPRGBank;
+static uint32_t m156_lastPRGBank;
+static uint32_t m156_CHRBank[8];
+
+void m156init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
+			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
+			uint8_t *chrROMin, uint32_t chrROMsizeIn)
+{
+	m156_prgROM = prgROMin;
+	m156_prgROMsize = prgROMsizeIn;
+	m156_prgROMand = mapperGetAndValue(prgROMsizeIn);
+	m156_prgRAM = prgRAMin;
+	m156_prgRAMsize = prgRAMsizeIn;
+	m156_prgRAMand = mapperGetAndValue(prgRAMsizeIn);
+	m156_curPRGBank = 0;
+	m156_lastPRGBank = (prgROMsizeIn - 0x4000);
+	if(chrROMsizeIn > 0)
+	{
+		m156_chrROM = chrROMin;
+		m156_chrROMsize = chrROMsizeIn;
+		m156_chrROMand = mapperGetAndValue(chrROMsizeIn);
+	}
+	else
+		printf("m156???\n");
+	memset(m156_CHRBank,0,8*sizeof(uint32_t));
+	ppuSetNameTblSingleLower(); //seems to be default state?
+	printf("Mapper 156 inited\n");
+}
+
+uint8_t m156get8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+		return m156_prgRAM[addr&0x1FFF];
+	else if(addr >= 0x8000)
+	{
+		if(addr < 0xC000)
+			return m156_prgROM[((m156_curPRGBank<<14)+(addr&0x3FFF))&m156_prgROMand];
+		return m156_prgROM[(m156_lastPRGBank+(addr&0x3FFF))&m156_prgROMand];
+	}
+	return val;
+}
+
+void m156set8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+	{
+		//printf("m156set8 %04x %02x\n", addr, val);
+		m156_prgRAM[addr&0x1FFF] = val;
+	}
+	else if(addr >= 0xC000 && addr < 0xC020)
+	{
+		switch(addr&0x1F)
+		{
+			case 0x0:
+				m156_CHRBank[0] = (m156_CHRBank[0]&0xFF00)|val;
+				break;
+			case 0x1:
+				m156_CHRBank[1] = (m156_CHRBank[1]&0xFF00)|val;
+				break;
+			case 0x2:
+				m156_CHRBank[2] = (m156_CHRBank[2]&0xFF00)|val;
+				break;
+			case 0x3:
+				m156_CHRBank[3] = (m156_CHRBank[3]&0xFF00)|val;
+				break;
+			case 0x4:
+				m156_CHRBank[0] = (m156_CHRBank[0]&0xFF)|(val<<8);
+				break;
+			case 0x5:
+				m156_CHRBank[1] = (m156_CHRBank[1]&0xFF)|(val<<8);
+				break;
+			case 0x6:
+				m156_CHRBank[2] = (m156_CHRBank[2]&0xFF)|(val<<8);
+				break;
+			case 0x7:
+				m156_CHRBank[3] = (m156_CHRBank[3]&0xFF)|(val<<8);
+				break;
+			case 0x8:
+				m156_CHRBank[4] = (m156_CHRBank[4]&0xFF00)|val;
+				break;
+			case 0x9:
+				m156_CHRBank[5] = (m156_CHRBank[5]&0xFF00)|val;
+				break;
+			case 0xA:
+				m156_CHRBank[6] = (m156_CHRBank[6]&0xFF00)|val;
+				break;
+			case 0xB:
+				m156_CHRBank[7] = (m156_CHRBank[7]&0xFF00)|val;
+				break;
+			case 0xC:
+				m156_CHRBank[4] = (m156_CHRBank[4]&0xFF)|(val<<8);
+				break;
+			case 0xD:
+				m156_CHRBank[5] = (m156_CHRBank[5]&0xFF)|(val<<8);
+				break;
+			case 0xE:
+				m156_CHRBank[6] = (m156_CHRBank[6]&0xFF)|(val<<8);
+				break;
+			case 0xF:
+				m156_CHRBank[7] = (m156_CHRBank[7]&0xFF)|(val<<8);
+				break;
+			case 0x10:
+				m156_curPRGBank = val;
+				break;
+			case 0x14:
+				if(val&1)
+					ppuSetNameTblHorizontal();
+				else
+					ppuSetNameTblVertical();
+				break;
+			default:
+				break;
+		}
+	}
+}
+
+uint8_t m156chrGet8(uint16_t addr)
+{
+	//printf("%04x\n",addr);
+	addr &= 0x1FFF;
+	if(addr < 0x400)
+		return m156_chrROM[((m156_CHRBank[0]<<10)+(addr&0x3FF))&m156_chrROMand];
+	else if(addr < 0x800)
+		return m156_chrROM[((m156_CHRBank[1]<<10)+(addr&0x3FF))&m156_chrROMand];
+	else if(addr < 0xC00)
+		return m156_chrROM[((m156_CHRBank[2]<<10)+(addr&0x3FF))&m156_chrROMand];
+	else if(addr < 0x1000)
+		return m156_chrROM[((m156_CHRBank[3]<<10)+(addr&0x3FF))&m156_chrROMand];
+	else if(addr < 0x1400)
+		return m156_chrROM[((m156_CHRBank[4]<<10)+(addr&0x3FF))&m156_chrROMand];
+	else if(addr < 0x1800)
+		return m156_chrROM[((m156_CHRBank[5]<<10)+(addr&0x3FF))&m156_chrROMand];
+	else if(addr < 0x1C00)
+		return m156_chrROM[((m156_CHRBank[6]<<10)+(addr&0x3FF))&m156_chrROMand];
+	return m156_chrROM[((m156_CHRBank[7]<<10)+(addr&0x3FF))&m156_chrROMand];
+}
+
+void m156chrSet8(uint16_t addr, uint8_t val)
+{
+	//printf("m156chrSet8 %04x %02x\n", addr, val);
+	(void)addr;
+	(void)val;
+}
+
diff --git a/mapper/m32.c b/mapper/m32.c
new file mode 100644
index 0000000..a04769c
--- /dev/null
+++ b/mapper/m32.c
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2017 FIX94
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <string.h>
+#include "../ppu.h"
+#include "../mapper.h"
+
+static uint8_t *m32_prgROM;
+static uint8_t *m32_prgRAM;
+static uint8_t *m32_chrROM;
+static uint32_t m32_prgROMsize;
+static uint32_t m32_prgRAMsize;
+static uint32_t m32_chrROMsize;
+static uint32_t m32_prgROMand;
+static uint32_t m32_prgRAMand;
+static uint32_t m32_chrROMand;
+static uint32_t m32_lastPRGBank;
+static uint32_t m32_lastM1PRGBank;
+static uint32_t m32_PRGBank[2];
+static uint32_t m32_CHRBank[8];
+static uint8_t m32_prgMode;
+//used externally
+bool m32_singlescreen;
+
+void m32init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
+			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
+			uint8_t *chrROMin, uint32_t chrROMsizeIn)
+{
+	m32_prgROM = prgROMin;
+	m32_prgROMsize = prgROMsizeIn;
+	m32_prgROMand = mapperGetAndValue(prgROMsizeIn);
+	m32_prgRAM = prgRAMin;
+	m32_prgRAMsize = prgRAMsizeIn;
+	m32_prgRAMand = mapperGetAndValue(prgRAMsizeIn);
+	m32_lastPRGBank = (prgROMsizeIn - 0x2000);
+	m32_lastM1PRGBank = m32_lastPRGBank - 0x2000;
+	if(chrROMsizeIn > 0)
+	{
+		m32_chrROM = chrROMin;
+		m32_chrROMsize = chrROMsizeIn;
+		m32_chrROMand = mapperGetAndValue(chrROMsizeIn);
+	}
+	else
+		printf("m32???\n");
+	memset(m32_PRGBank,0,2*sizeof(uint32_t));
+	memset(m32_CHRBank,0,8*sizeof(uint32_t));
+	m32_prgMode = 0;
+	if(m32_singlescreen)
+		ppuSetNameTblSingleLower();
+	printf("Mapper 32 inited\n");
+}
+
+uint8_t m32get8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+		return m32_prgRAM[addr&0x1FFF];
+	else if(addr >= 0x8000)
+	{
+		if(m32_prgMode == 0)
+		{
+			if(addr < 0xA000)
+				return m32_prgROM[((m32_PRGBank[0]<<13)+(addr&0x1FFF))&m32_prgROMand];
+			else if(addr < 0xC000)
+				return m32_prgROM[((m32_PRGBank[1]<<13)+(addr&0x1FFF))&m32_prgROMand];
+			else if(addr < 0xE000)
+				return m32_prgROM[(m32_lastM1PRGBank+(addr&0x1FFF))&m32_prgROMand];
+			return m32_prgROM[(m32_lastPRGBank+(addr&0x1FFF))&m32_prgROMand];
+		}
+		else
+		{
+			if(addr < 0xA000)
+				return m32_prgROM[(m32_lastM1PRGBank+(addr&0x1FFF))&m32_prgROMand];
+			else if(addr < 0xC000)
+				return m32_prgROM[((m32_PRGBank[1]<<13)+(addr&0x1FFF))&m32_prgROMand];
+			else if(addr < 0xE000)
+				return m32_prgROM[((m32_PRGBank[0]<<13)+(addr&0x1FFF))&m32_prgROMand];
+			return m32_prgROM[(m32_lastPRGBank+(addr&0x1FFF))&m32_prgROMand];
+		}
+	}
+	return val;
+}
+
+void m32set8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+	{
+		//printf("m32set8 %04x %02x\n", addr, val);
+		m32_prgRAM[addr&0x1FFF] = val;
+	}
+	else if(addr >= 0x8000)
+	{
+		if(addr < 0x9000)
+			m32_PRGBank[0] = val&0x1F;
+		else if(addr < 0xA000)
+		{
+			if(!m32_singlescreen)
+			{
+				if(val&1)
+					ppuSetNameTblHorizontal();
+				else
+					ppuSetNameTblVertical();
+				m32_prgMode = !!(val&2);
+			}
+		}
+		else if(addr < 0xB000)
+			m32_PRGBank[1] = val;
+		else if(addr < 0xC000)
+		{
+			switch(addr&7)
+			{
+				case 0x0:
+					m32_CHRBank[0] = val;
+					break;
+				case 0x1:
+					m32_CHRBank[1] = val;
+					break;
+				case 0x2:
+					m32_CHRBank[2] = val;
+					break;
+				case 0x3:
+					m32_CHRBank[3] = val;
+					break;
+				case 0x4:
+					m32_CHRBank[4] = val;
+					break;
+				case 0x5:
+					m32_CHRBank[5] = val;
+					break;
+				case 0x6:
+					m32_CHRBank[6] = val;
+					break;
+				case 0x7:
+					m32_CHRBank[7] = val;
+					break;
+				default:
+					break;
+			}
+		}
+	}
+}
+
+uint8_t m32chrGet8(uint16_t addr)
+{
+	//printf("%04x\n",addr);
+	addr &= 0x1FFF;
+	if(addr < 0x400)
+		return m32_chrROM[((m32_CHRBank[0]<<10)+(addr&0x3FF))&m32_chrROMand];
+	else if(addr < 0x800)
+		return m32_chrROM[((m32_CHRBank[1]<<10)+(addr&0x3FF))&m32_chrROMand];
+	else if(addr < 0xC00)
+		return m32_chrROM[((m32_CHRBank[2]<<10)+(addr&0x3FF))&m32_chrROMand];
+	else if(addr < 0x1000)
+		return m32_chrROM[((m32_CHRBank[3]<<10)+(addr&0x3FF))&m32_chrROMand];
+	else if(addr < 0x1400)
+		return m32_chrROM[((m32_CHRBank[4]<<10)+(addr&0x3FF))&m32_chrROMand];
+	else if(addr < 0x1800)
+		return m32_chrROM[((m32_CHRBank[5]<<10)+(addr&0x3FF))&m32_chrROMand];
+	else if(addr < 0x1C00)
+		return m32_chrROM[((m32_CHRBank[6]<<10)+(addr&0x3FF))&m32_chrROMand];
+	return m32_chrROM[((m32_CHRBank[7]<<10)+(addr&0x3FF))&m32_chrROMand];
+}
+
+void m32chrSet8(uint16_t addr, uint8_t val)
+{
+	//printf("m32chrSet8 %04x %02x\n", addr, val);
+	(void)addr;
+	(void)val;
+}
+
diff --git a/mapper/m4add.c b/mapper/m4add.c
index ebaff41..40ab3d0 100644
--- a/mapper/m4add.c
+++ b/mapper/m4add.c
@@ -76,6 +76,28 @@ void m47_init(uint8_t *prgROMin, uint32_t prgROMsizeIn,
 	printf("Mapper 47 (Mapper 4 Game Select) inited\n");
 }
 
+static uint8_t m49_prgmode;
+static uint8_t m49_prgreg;
+static uint8_t *m49_prgROM;
+
+void m49_init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
+			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
+			uint8_t *chrROMin, uint32_t chrROMsizeIn)
+{
+	m4init(prgROMin, prgROMsizeIn, prgRAMin, prgRAMsizeIn, chrROMin, chrROMsizeIn);
+	//start with default config
+	m4_prgROMadd = 0;
+	m4_prgROMand = 0x1FFFF;
+	m4_chrROMadd = 0;
+	m4_chrROMand = 0x1FFFF;
+	m4add_regLock = false;
+	m49_prgmode = 0;
+	m49_prgreg = 0;
+	//for prg mode
+	m49_prgROM = prgROMin;
+	printf("Mapper 49 (Mapper 4 Game Select) inited\n");
+}
+
 void m52_init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
 			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
 			uint8_t *chrROMin, uint32_t chrROMsizeIn)
@@ -255,6 +277,53 @@ void m47_set8(uint16_t addr, uint8_t val)
 		m4set8(addr, val);
 }
 
+void m49_set8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+	{
+		if(!m4add_regLock)
+		{
+			switch(val>>6)
+			{
+				case 0:
+					m4_prgROMadd = 0;
+					m4_prgROMand = 0x1FFFF;
+					m4_chrROMadd = 0;
+					m4_chrROMand = 0x1FFFF;
+					break;
+				case 1:
+					m4_prgROMadd = 0x20000;
+					m4_prgROMand = 0x1FFFF;
+					m4_chrROMadd = 0x20000;
+					m4_chrROMand = 0x1FFFF;
+					break;
+				case 2:
+					m4_prgROMadd = 0x40000;
+					m4_prgROMand = 0x1FFFF;
+					m4_chrROMadd = 0x40000;
+					m4_chrROMand = 0x1FFFF;
+					break;
+				case 3:
+					m4_prgROMadd = 0x60000;
+					m4_prgROMand = 0x1FFFF;
+					m4_chrROMadd = 0x60000;
+					m4_chrROMand = 0x1FFFF;
+					break;
+				default:
+					break;
+			}
+			m49_prgmode = val&1;
+			m49_prgreg = (val>>4)&3;
+		}
+	}
+	else if(addr >= 0x8000)
+	{
+		if(addr >= 0xA000 && addr < 0xC000 && (addr&1))
+			m4add_regLock = ((val&0x80) == 0);
+		m4set8(addr, val);
+	}
+}
+
 void m52_set8(uint16_t addr, uint8_t val)
 {
 	if(addr < 0x8000 && addr >= 0x6000)
@@ -328,3 +397,15 @@ void m205_set8(uint16_t addr, uint8_t val)
 	else if(addr >= 0x8000)
 		m4set8(addr, val);
 }
+
+uint8_t m49_get8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x8000)
+	{
+		if(m49_prgmode == 0)
+			return m49_prgROM[(addr&0x7FFF)|(m49_prgreg<<15)|m4_prgROMadd];
+		else
+			return m4get8(addr, val);
+	}
+	return val;
+}
diff --git a/mapper/m65.c b/mapper/m65.c
new file mode 100644
index 0000000..53f48af
--- /dev/null
+++ b/mapper/m65.c
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2017 FIX94
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <string.h>
+#include "../ppu.h"
+#include "../mapper.h"
+
+static uint8_t *m65_prgROM;
+static uint8_t *m65_prgRAM;
+static uint8_t *m65_chrROM;
+static uint32_t m65_prgROMsize;
+static uint32_t m65_prgRAMsize;
+static uint32_t m65_chrROMsize;
+static uint32_t m65_prgROMand;
+static uint32_t m65_prgRAMand;
+static uint32_t m65_chrROMand;
+static uint32_t m65_lastPRGBank;
+static uint32_t m65_PRGBank[3];
+static uint32_t m65_CHRBank[8];
+static uint16_t m65_irqCtr;
+static uint16_t m65_irqReloadCtr;
+static bool m65_irqEnable;
+extern bool mapper_interrupt;
+
+void m65init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
+			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
+			uint8_t *chrROMin, uint32_t chrROMsizeIn)
+{
+	m65_prgROM = prgROMin;
+	m65_prgROMsize = prgROMsizeIn;
+	m65_prgROMand = mapperGetAndValue(prgROMsizeIn);
+	m65_prgRAM = prgRAMin;
+	m65_prgRAMsize = prgRAMsizeIn;
+	m65_prgRAMand = mapperGetAndValue(prgRAMsizeIn);
+	m65_lastPRGBank = (prgROMsizeIn - 0x2000);
+	if(chrROMsizeIn > 0)
+	{
+		m65_chrROM = chrROMin;
+		m65_chrROMsize = chrROMsizeIn;
+		m65_chrROMand = mapperGetAndValue(chrROMsizeIn);
+	}
+	else
+		printf("M65???\n");
+	m65_PRGBank[0] = 0;
+	m65_PRGBank[1] = 1;
+	m65_PRGBank[2] = 0xFE;
+	memset(m65_CHRBank,0,8*sizeof(uint32_t));
+	m65_irqCtr = 0;
+	m65_irqReloadCtr = 0;
+	m65_irqEnable = false;
+	printf("Mapper 65 inited\n");
+}
+
+uint8_t m65get8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+		return m65_prgRAM[addr&0x1FFF];
+	else if(addr >= 0x8000)
+	{
+		if(addr < 0xA000)
+			return m65_prgROM[((m65_PRGBank[0]<<13)+(addr&0x1FFF))&m65_prgROMand];
+		else if(addr < 0xC000)
+			return m65_prgROM[((m65_PRGBank[1]<<13)+(addr&0x1FFF))&m65_prgROMand];
+		else if(addr < 0xE000)
+			return m65_prgROM[((m65_PRGBank[2]<<13)+(addr&0x1FFF))&m65_prgROMand];
+		return m65_prgROM[(m65_lastPRGBank+(addr&0x1FFF))&m65_prgROMand];
+	}
+	return val;
+}
+
+void m65set8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+	{
+		//printf("m65set8 %04x %02x\n", addr, val);
+		m65_prgRAM[addr&0x1FFF] = val;
+	}
+	else if(addr >= 0x8000)
+	{
+		if(addr < 0x9000)
+			m65_PRGBank[0] = val;
+		else if(addr < 0xA000)
+		{
+			switch(addr&7)
+			{
+				case 1:
+					if(val&0x80)
+						ppuSetNameTblHorizontal();
+					else
+						ppuSetNameTblVertical();
+					break;
+				case 3:
+					m65_irqEnable = !!(val&0x80);
+					mapper_interrupt = false;
+					break;
+				case 4:
+					m65_irqCtr = m65_irqReloadCtr;
+					mapper_interrupt = false;
+					break;
+				case 5:
+					m65_irqReloadCtr = (m65_irqReloadCtr&0xFF) | (val<<8);
+					break;
+				case 6:
+					m65_irqReloadCtr = (m65_irqReloadCtr&~0xFF) | val;
+					break;
+				default:
+					break;
+			}
+		}
+		else if(addr < 0xB000)
+			m65_PRGBank[1] = val;
+		else if(addr < 0xC000)
+		{
+			switch(addr&7)
+			{
+				case 0x0:
+					m65_CHRBank[0] = val;
+					break;
+				case 0x1:
+					m65_CHRBank[1] = val;
+					break;
+				case 0x2:
+					m65_CHRBank[2] = val;
+					break;
+				case 0x3:
+					m65_CHRBank[3] = val;
+					break;
+				case 0x4:
+					m65_CHRBank[4] = val;
+					break;
+				case 0x5:
+					m65_CHRBank[5] = val;
+					break;
+				case 0x6:
+					m65_CHRBank[6] = val;
+					break;
+				case 0x7:
+					m65_CHRBank[7] = val;
+					break;
+				default:
+					break;
+			}
+		}
+		else if(addr < 0xD000)
+			m65_PRGBank[2] = val;
+	}
+}
+
+uint8_t m65chrGet8(uint16_t addr)
+{
+	//printf("%04x\n",addr);
+	addr &= 0x1FFF;
+	if(addr < 0x400)
+		return m65_chrROM[((m65_CHRBank[0]<<10)+(addr&0x3FF))&m65_chrROMand];
+	else if(addr < 0x800)
+		return m65_chrROM[((m65_CHRBank[1]<<10)+(addr&0x3FF))&m65_chrROMand];
+	else if(addr < 0xC00)
+		return m65_chrROM[((m65_CHRBank[2]<<10)+(addr&0x3FF))&m65_chrROMand];
+	else if(addr < 0x1000)
+		return m65_chrROM[((m65_CHRBank[3]<<10)+(addr&0x3FF))&m65_chrROMand];
+	else if(addr < 0x1400)
+		return m65_chrROM[((m65_CHRBank[4]<<10)+(addr&0x3FF))&m65_chrROMand];
+	else if(addr < 0x1800)
+		return m65_chrROM[((m65_CHRBank[5]<<10)+(addr&0x3FF))&m65_chrROMand];
+	else if(addr < 0x1C00)
+		return m65_chrROM[((m65_CHRBank[6]<<10)+(addr&0x3FF))&m65_chrROMand];
+	return m65_chrROM[((m65_CHRBank[7]<<10)+(addr&0x3FF))&m65_chrROMand];
+}
+
+void m65chrSet8(uint16_t addr, uint8_t val)
+{
+	//printf("m65chrSet8 %04x %02x\n", addr, val);
+	(void)addr;
+	(void)val;
+}
+
+void m65cycle()
+{
+	if(m65_irqCtr && m65_irqEnable)
+	{
+		m65_irqCtr--;
+		if(m65_irqCtr == 0)
+			mapper_interrupt = true;
+	}
+}
diff --git a/mapper/p16c8.c b/mapper/p16c8.c
index 4620818..0ad9c19 100644
--- a/mapper/p16c8.c
+++ b/mapper/p16c8.c
@@ -58,6 +58,23 @@ void p16c8init(uint8_t *prgROMin, uint32_t prgROMsizeIn,
 	printf("16k PRG 8k CHR Mapper inited\n");
 }
 
+static bool m60_ready;
+static uint8_t m60_state;
+static uint32_t m60_prgROMadd;
+static uint32_t m60_chrROMadd;
+
+void m60_init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
+			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
+			uint8_t *chrROMin, uint32_t chrROMsizeIn)
+{
+	p16c8init(prgROMin, prgROMsizeIn, prgRAMin, prgRAMsizeIn, chrROMin, chrROMsizeIn);
+	m60_ready = true;
+	m60_state = 0;
+	m60_prgROMadd = 0;
+	m60_chrROMadd = 0;
+}
+
+
 void m174_init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
 			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
 			uint8_t *chrROMin, uint32_t chrROMsizeIn)
@@ -85,6 +102,44 @@ uint8_t p1632c8get8(uint16_t addr, uint8_t val)
 	return p16c8_prgROM[((p16c8_curPRGBank&~0x7FFF)+(addr&0x7FFF))&p16c8_prgROMand];
 }
 
+uint8_t m60_get8(uint16_t addr, uint8_t val)
+{
+	if(addr < 0x8000)
+		return val;
+	//determine reset by reading reset vector
+	if(addr == 0xFFFC && m60_ready)
+	{
+		m60_ready = false;
+		switch(m60_state)
+		{
+			case 0:
+				m60_prgROMadd = 0;
+				m60_chrROMadd = 0;
+				break;
+			case 1:
+				m60_prgROMadd = 0x4000;
+				m60_chrROMadd = 0x2000;
+				break;
+			case 2:
+				m60_prgROMadd = 0x8000;
+				m60_chrROMadd = 0x4000;
+				break;
+			case 3:
+				m60_prgROMadd = 0xC000;
+				m60_chrROMadd = 0x6000;
+				break;
+			default:
+				break;
+		}
+		m60_state++;
+		m60_state&=3;
+	}
+	//only allow another reset after full reset vector read
+	if(addr == 0xFFFD && !m60_ready)
+		m60_ready = true;
+	return p16c8_prgROM[(addr&0x3FFF)+m60_prgROMadd];
+}
+
 uint8_t m97_get8(uint16_t addr, uint8_t val)
 {
 	if(addr < 0x8000)
@@ -172,6 +227,12 @@ void m58_set8(uint16_t addr, uint8_t val)
 		ppuSetNameTblVertical();
 }
 
+void m60_set8(uint16_t addr, uint8_t val)
+{
+	(void)val;
+	(void)addr;
+}
+
 void m61_set8(uint16_t addr, uint8_t val)
 {
 	(void)val;
@@ -454,3 +515,15 @@ void p16c8chrSet8(uint16_t addr, uint8_t val)
 	if(p16c8_chrROM == p16c8_chrRAM) //Writable
 		p16c8_chrROM[addr&0x1FFF] = val;
 }
+
+uint8_t m60_chrGet8(uint16_t addr)
+{
+	return p16c8_chrROM[(addr&0x1FFF)+m60_chrROMadd];
+}
+
+void m60_chrSet8(uint16_t addr, uint8_t val)
+{
+	(void)addr;
+	(void)val;
+}
+
diff --git a/mapper/s5b.c b/mapper/s5b.c
index db7d68c..4b0c974 100644
--- a/mapper/s5b.c
+++ b/mapper/s5b.c
@@ -22,7 +22,6 @@ static uint32_t s5B_chrROMsize;
 static uint32_t s5B_prgROMand;
 static uint32_t s5B_prgRAMand;
 static uint32_t s5B_chrROMand;
-static uint8_t s5B_chrRAM[0x2000];
 static uint32_t s5B_lastPRGBank;
 static uint32_t s5B_PRGBank[4];
 static uint32_t s5B_CHRBank[8];
@@ -52,12 +51,7 @@ void s5Binit(uint8_t *prgROMin, uint32_t prgROMsizeIn,
 		s5B_chrROMand = mapperGetAndValue(chrROMsizeIn);
 	}
 	else
-	{
-		s5B_chrROM = s5B_chrRAM;
-		s5B_chrROMsize = 0x2000;
-		s5B_chrROMand = 0x1FFF;
-	}
-	memset(s5B_chrRAM,0,0x2000);
+		printf("S5B???\n");
 	memset(s5B_PRGBank,0,4*sizeof(uint32_t));
 	memset(s5B_CHRBank,0,8*sizeof(uint32_t));
 	s5B_irqCtr = 0;
diff --git a/mapper/vrc3.c b/mapper/vrc3.c
new file mode 100644
index 0000000..9db3e9b
--- /dev/null
+++ b/mapper/vrc3.c
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2017 FIX94
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <inttypes.h>
+#include <string.h>
+#include "../ppu.h"
+#include "../mapper.h"
+
+static uint8_t *vrc3_prgROM;
+static uint8_t *vrc3_prgRAM;
+static uint8_t *vrc3_chrROM;
+static uint8_t vrc3_chrRAM[0x2000];
+static uint32_t vrc3_prgROMsize;
+static uint32_t vrc3_prgRAMsize;
+static uint32_t vrc3_chrROMsize;
+static uint32_t vrc3_curPRGBank;
+static uint32_t vrc3_lastPRGBank;
+static uint32_t vrc3_prgROMand;
+static uint32_t vrc3_chrROMand;
+static uint16_t vrc3_irqCtr;
+static uint16_t vrc3_irqReloadCtr;
+static bool vrc3_irqEnable;
+static bool vrc3_irqEnable_after_ack;
+static bool vrc3_irq8Bit;
+extern bool mapper_interrupt;
+
+void vrc3init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
+			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
+			uint8_t *chrROMin, uint32_t chrROMsizeIn)
+{
+	vrc3_prgROM = prgROMin;
+	vrc3_prgROMsize = prgROMsizeIn;
+	vrc3_prgRAM = prgRAMin;
+	vrc3_prgRAMsize = prgRAMsizeIn;
+	vrc3_curPRGBank = 0;
+	vrc3_lastPRGBank = (prgROMsizeIn - 0x4000);
+	vrc3_prgROMand = mapperGetAndValue(prgROMsizeIn);
+	if(chrROMin && chrROMsizeIn)
+	{
+		vrc3_chrROM = chrROMin;
+		vrc3_chrROMsize = chrROMsizeIn;
+		vrc3_chrROMand = mapperGetAndValue(chrROMsizeIn);
+	}
+	else
+	{
+		vrc3_chrROM = vrc3_chrRAM;
+		vrc3_chrROMsize = 0x2000;
+		vrc3_chrROMand = 0x1FFF;
+	}
+	memset(vrc3_chrRAM, 0, 0x2000);
+	vrc3_irqCtr = 0;
+	vrc3_irqReloadCtr = 0;
+	vrc3_irqEnable = false;
+	vrc3_irqEnable_after_ack = false;
+	vrc3_irq8Bit = false;
+	printf("vrc3 Mapper inited\n");
+}
+
+uint8_t vrc3get8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+		return vrc3_prgRAM[addr&0x1FFF];
+	else if(addr >= 0x8000)
+	{
+		if(addr < 0xC000)
+			return vrc3_prgROM[(((vrc3_curPRGBank<<14)+(addr&0x3FFF))&vrc3_prgROMand)];
+		return vrc3_prgROM[((vrc3_lastPRGBank+(addr&0x3FFF))&vrc3_prgROMand)];
+	}
+	return val;
+}
+
+void vrc3set8(uint16_t addr, uint8_t val)
+{
+	if(addr >= 0x6000 && addr < 0x8000)
+	{
+		vrc3_prgRAM[addr&0x1FFF] = val;
+		return;
+	}
+	else if(addr < 0x9000)
+		vrc3_irqReloadCtr = (vrc3_irqReloadCtr&0xFFF0)|((val&0xF)<<0);
+	else if(addr < 0xA000)
+		vrc3_irqReloadCtr = (vrc3_irqReloadCtr&0xFF0F)|((val&0xF)<<4);
+	else if(addr < 0xB000)
+		vrc3_irqReloadCtr = (vrc3_irqReloadCtr&0xF0FF)|((val&0xF)<<8);
+	else if(addr < 0xC000)
+		vrc3_irqReloadCtr = (vrc3_irqReloadCtr&0x0FFF)|((val&0xF)<<12);
+	else if(addr < 0xD000)
+	{
+		mapper_interrupt = false;
+		vrc3_irqEnable_after_ack = !!(val&1);
+		vrc3_irqEnable = !!(val&2);
+		vrc3_irq8Bit = !!(val&4);
+		if(vrc3_irqEnable)
+			vrc3_irqCtr = vrc3_irqReloadCtr;
+	}
+	else if(addr < 0xE000)
+	{
+		mapper_interrupt = false;
+		vrc3_irqEnable = vrc3_irqEnable_after_ack;
+	}
+	else if(addr >= 0xF000)
+		vrc3_curPRGBank = (val&7);
+}
+
+uint8_t vrc3chrGet8(uint16_t addr)
+{
+	return vrc3_chrROM[addr&0x1FFF];
+}
+
+void vrc3chrSet8(uint16_t addr, uint8_t val)
+{
+	if(vrc3_chrROM == vrc3_chrRAM)
+		vrc3_chrRAM[addr&0x1FFF] = val;
+}
+
+void vrc3cycle()
+{
+	if(vrc3_irqEnable)
+	{
+		if(vrc3_irq8Bit)
+		{
+			uint8_t tmp = vrc3_irqCtr&0xFF;
+			tmp++;
+			vrc3_irqCtr = (vrc3_irqCtr&0xFF00)|tmp;
+			if(tmp == 0)
+			{
+				vrc3_irqEnable = false;
+				mapper_interrupt = true;
+				vrc3_irqCtr = (vrc3_irqCtr&0xFF00)|(vrc3_irqReloadCtr&0xFF);
+			}
+		}
+		else
+		{
+			vrc3_irqCtr++;
+			if(vrc3_irqCtr == 0)
+			{
+				vrc3_irqEnable = false;
+				mapper_interrupt = true;
+				vrc3_irqCtr = vrc3_irqReloadCtr;
+			}
+		}
+	}
+}
diff --git a/mapperList.c b/mapperList.c
index b986bed..3a430e5 100644
--- a/mapperList.c
+++ b/mapperList.c
@@ -17,7 +17,10 @@
 #include "mapper_h/m10.h"
 #include "mapper_h/m13.h"
 #include "mapper_h/m15.h"
+#include "mapper_h/m32.h"
 #include "mapper_h/m48.h"
+#include "mapper_h/m65.h"
+#include "mapper_h/m156.h"
 #include "mapper_h/m206.h"
 #include "mapper_h/m225.h"
 #include "mapper_h/m228.h"
@@ -29,6 +32,7 @@
 #include "mapper_h/p32c8.h"
 #include "mapper_h/vrc1.h"
 #include "mapper_h/vrc2_4.h"
+#include "mapper_h/vrc3.h"
 #include "mapper_h/vrc6.h"
 #include "mapper_h/vrc7.h"
 #include "mapper_h/s3.h"
@@ -70,7 +74,7 @@ mapperList_t mapperList[256] = {
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
-	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
+	{ m32init,		m32get8,		m32set8,		m32chrGet8,		m32chrSet8,		NULL,	NULL,	NULL },
 	{ m48init,		m48get8,		m33set8,		m48chrGet8,		m48chrSet8,		NULL,	NULL,	NULL },
 	{ p32c4init,	p32c4get8,		p32c4set8,		p32c4chrGet8,	p32c4chrSet8,	NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
@@ -87,7 +91,7 @@ mapperList_t mapperList[256] = {
 	{ p32c8init,	p32c8get8,		m46_set8,		p32c8chrGet8,	p32c8chrSet8,	NULL,	NULL,	NULL },
 	{ m47_init,		m4get8,			m47_set8,		m4chrGet8,		m4chrSet8,		NULL,	NULL,	m4cycle },
 	{ m48init,		m48get8,		m48set8,		m48chrGet8,		m48chrSet8,		NULL,	NULL,	m48cycle },
-	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
+	{ m49_init,		m49_get8,		m49_set8,		m4chrGet8,		m4chrSet8,		NULL,	NULL,	m4cycle },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ m52_init,		m4get8,			m52_set8,		m4chrGet8,		m4chrSet8,		NULL,	NULL,	m4cycle },
@@ -98,12 +102,12 @@ mapperList_t mapperList[256] = {
 	{ m174_init,	p1632c8get8,	m57_set8,		p16c8chrGet8,	p16c8chrSet8,	NULL,	NULL,	NULL },
 	{ p16c8init,	p1632c8get8,	m58_set8,		p16c8chrGet8,	p16c8chrSet8,	NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
-	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
+	{ m60_init,		m60_get8,		m60_set8,		m60_chrGet8,	m60_chrSet8,	NULL,	NULL,	NULL },
 	{ p16c8init,	p1632c8get8,	m61_set8,		p16c8chrGet8,	p16c8chrSet8,	NULL,	NULL,	NULL },
 	{ p16c8init,	p1632c8get8,	m62_set8,		p16c8chrGet8,	p16c8chrSet8,	NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
-	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
+	{ m65init,		m65get8,		m65set8,		m65chrGet8,		m65chrSet8,		NULL,	NULL,	m65cycle },
 	{ p32c8init,	p32c8get8,		m66_set8,		p32c8chrGet8,	p32c8chrSet8,	NULL,	NULL,	NULL },
 	{ s3init,		s3get8,			s3set8,			s3chrGet8,		s3chrSet8,		NULL,	NULL,	s3cycle },
 	{ s4init,		s4get8,			s4set8,			s4chrGet8,		s4chrSet8,		s4vramGet8, s4vramSet8,	NULL },
@@ -111,7 +115,7 @@ mapperList_t mapperList[256] = {
 	{ p16c8init,	p16c8get8,		m70_set8,		p16c8chrGet8,	p16c8chrSet8,	NULL,	NULL,	NULL },
 	{ p16c8init,	p16c8get8,		m71_set8,		p16c8chrGet8,	p16c8chrSet8,	NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
-	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
+	{ vrc3init,		vrc3get8,		vrc3set8,		vrc3chrGet8,	vrc3chrSet8,	NULL,	NULL,	vrc3cycle },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ vrc1init,		vrc1get8,		vrc1set8,		vrc1chrGet8,	vrc1chrSet8,	NULL,	NULL,	NULL },
 	{ m206init,		m206get8,		m206set8,		m76chrGet8,		m206chrSet8,	NULL,	NULL,	NULL },
@@ -193,8 +197,8 @@ mapperList_t mapperList[256] = {
 	{ p16c8init,	p16c8get8,		m152_set8,		p16c8chrGet8,	p16c8chrSet8,	NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ m206init,		m206get8,		m154set8,		m88chrGet8,		m206chrSet8,	NULL,	NULL,	NULL },
-	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
-	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
+	{ m1init,		m1get8,			m1set8,			m1chrGet8,		m1chrSet8,		NULL,	NULL,	NULL },
+	{ m156init,		m156get8,		m156set8,		m156chrGet8,	m156chrSet8,	NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
 	{ NULL,			NULL,			NULL,			NULL,			NULL,			NULL,	NULL,	NULL },
diff --git a/mapper_h/m156.h b/mapper_h/m156.h
new file mode 100644
index 0000000..e403bbb
--- /dev/null
+++ b/mapper_h/m156.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2017 FIX94
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+
+#ifndef m156_h_
+#define m156_h_
+
+void m156init(uint8_t *prgROM, uint32_t prgROMsize, 
+			uint8_t *prgRAM, uint32_t prgRAMsize,
+			uint8_t *chrROM, uint32_t chrROMsize);
+uint8_t m156get8(uint16_t addr, uint8_t val);
+void m156set8(uint16_t addr, uint8_t val);
+uint8_t m156chrGet8(uint16_t addr);
+void m156chrSet8(uint16_t addr, uint8_t val);
+
+#endif
diff --git a/mapper_h/m32.h b/mapper_h/m32.h
new file mode 100644
index 0000000..596cecc
--- /dev/null
+++ b/mapper_h/m32.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2017 FIX94
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+
+#ifndef m32_h_
+#define m32_h_
+
+void m32init(uint8_t *prgROM, uint32_t prgROMsize, 
+			uint8_t *prgRAM, uint32_t prgRAMsize,
+			uint8_t *chrROM, uint32_t chrROMsize);
+uint8_t m32get8(uint16_t addr, uint8_t val);
+void m32set8(uint16_t addr, uint8_t val);
+uint8_t m32chrGet8(uint16_t addr);
+void m32chrSet8(uint16_t addr, uint8_t val);
+
+#endif
diff --git a/mapper_h/m4add.h b/mapper_h/m4add.h
index affd263..435cbd9 100644
--- a/mapper_h/m4add.h
+++ b/mapper_h/m4add.h
@@ -20,6 +20,9 @@ void m45_init(uint8_t *prgROMin, uint32_t prgROMsizeIn,
 void m47_init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
 			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
 			uint8_t *chrROMin, uint32_t chrROMsizeIn);
+void m49_init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
+			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
+			uint8_t *chrROMin, uint32_t chrROMsizeIn);
 void m52_init(uint8_t *prgROMin, uint32_t prgROMsizeIn, 
 			uint8_t *prgRAMin, uint32_t prgRAMsizeIn,
 			uint8_t *chrROMin, uint32_t chrROMsizeIn);
@@ -30,7 +33,9 @@ void m37_set8(uint16_t addr, uint8_t val);
 void m44_set8(uint16_t addr, uint8_t val);
 void m45_set8(uint16_t addr, uint8_t val);
 void m47_set8(uint16_t addr, uint8_t val);
+void m49_set8(uint16_t addr, uint8_t val);
 void m52_set8(uint16_t addr, uint8_t val);
 void m205_set8(uint16_t addr, uint8_t val);
+uint8_t m49_get8(uint16_t addr, uint8_t val);
 
 #endif
diff --git a/mapper_h/m65.h b/mapper_h/m65.h
new file mode 100644
index 0000000..cdae679
--- /dev/null
+++ b/mapper_h/m65.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2017 FIX94
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+
+#ifndef m65_h_
+#define m65_h_
+
+void m65init(uint8_t *prgROM, uint32_t prgROMsize, 
+			uint8_t *prgRAM, uint32_t prgRAMsize,
+			uint8_t *chrROM, uint32_t chrROMsize);
+uint8_t m65get8(uint16_t addr, uint8_t val);
+void m65set8(uint16_t addr, uint8_t val);
+uint8_t m65chrGet8(uint16_t addr);
+void m65chrSet8(uint16_t addr, uint8_t val);
+void m65cycle();
+
+#endif
diff --git a/mapper_h/p16c8.h b/mapper_h/p16c8.h
index db3abeb..1d70bbf 100644
--- a/mapper_h/p16c8.h
+++ b/mapper_h/p16c8.h
@@ -11,11 +11,15 @@
 void p16c8init(uint8_t *prgROM, uint32_t prgROMsize, 
 			uint8_t *prgRAM, uint32_t prgRAMsize,
 			uint8_t *chrROM, uint32_t chrROMsize);
+void m60_init(uint8_t *prgROM, uint32_t prgROMsize, 
+			uint8_t *prgRAM, uint32_t prgRAMsize,
+			uint8_t *chrROM, uint32_t chrROMsize);
 void m174_init(uint8_t *prgROM, uint32_t prgROMsize, 
 			uint8_t *prgRAM, uint32_t prgRAMsize,
 			uint8_t *chrROM, uint32_t chrROMsize);
 uint8_t p16c8get8(uint16_t addr, uint8_t val);
 uint8_t p1632c8get8(uint16_t addr, uint8_t val);
+uint8_t m60_get8(uint16_t addr, uint8_t val);
 uint8_t m97_get8(uint16_t addr, uint8_t val);
 uint8_t m180_get8(uint16_t addr, uint8_t val);
 uint8_t m200_get8(uint16_t addr, uint8_t val);
@@ -24,6 +28,7 @@ uint8_t m232_get8(uint16_t addr, uint8_t val);
 void m2_set8(uint16_t addr, uint8_t val);
 void m57_set8(uint16_t addr, uint8_t val);
 void m58_set8(uint16_t addr, uint8_t val);
+void m60_set8(uint16_t addr, uint8_t val);
 void m61_set8(uint16_t addr, uint8_t val);
 void m62_set8(uint16_t addr, uint8_t val);
 void m70_set8(uint16_t addr, uint8_t val);
@@ -46,5 +51,7 @@ void m231_set8(uint16_t addr, uint8_t val);
 void m232_set8(uint16_t addr, uint8_t val);
 uint8_t p16c8chrGet8(uint16_t addr);
 void p16c8chrSet8(uint16_t addr, uint8_t val);
+uint8_t m60_chrGet8(uint16_t addr);
+void m60_chrSet8(uint16_t addr, uint8_t val);
 
 #endif
diff --git a/mapper_h/vrc3.h b/mapper_h/vrc3.h
new file mode 100644
index 0000000..1da0178
--- /dev/null
+++ b/mapper_h/vrc3.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2017 FIX94
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+
+#ifndef vrc3_h_
+#define vrc3_h_
+
+void vrc3init(uint8_t *prgROM, uint32_t prgROMsize, 
+			uint8_t *prgRAM, uint32_t prgRAMsize,
+			uint8_t *chrROM, uint32_t chrROMsize);
+uint8_t vrc3get8(uint16_t addr, uint8_t val);
+void vrc3set8(uint16_t addr, uint8_t val);
+uint8_t vrc3chrGet8(uint16_t addr);
+void vrc3chrSet8(uint16_t addr, uint8_t val);
+void vrc3cycle();
+
+#endif