@@ -1,179 +1,8 @@

-/***********************************************************************************

+/*****************************************************************************\

   Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.

-

-  (c) Copyright 1996 - 2002  Gary Henderson (gary.henderson@ntlworld.com),

-                             Jerremy Koot (jkoot@snes9x.com)

-

-  (c) Copyright 2002 - 2004  Matthew Kendora

-

-  (c) Copyright 2002 - 2005  Peter Bortas (peter@bortas.org)

-

-  (c) Copyright 2004 - 2005  Joel Yliluoma (http://iki.fi/bisqwit/)

-

-  (c) Copyright 2001 - 2006  John Weidman (jweidman@slip.net)

-

-  (c) Copyright 2002 - 2006  funkyass (funkyass@spam.shaw.ca),

-                             Kris Bleakley (codeviolation@hotmail.com)

-

-  (c) Copyright 2002 - 2010  Brad Jorsch (anomie@users.sourceforge.net),

-                             Nach (n-a-c-h@users.sourceforge.net),

-

-  (c) Copyright 2002 - 2011  zones (kasumitokoduck@yahoo.com)

-

-  (c) Copyright 2006 - 2007  nitsuja

-

-  (c) Copyright 2009 - 2011  BearOso,

-                             OV2

-

-

-  BS-X C emulator code

-  (c) Copyright 2005 - 2006  Dreamer Nom,

-                             zones

-

-  C4 x86 assembler and some C emulation code

-  (c) Copyright 2000 - 2003  _Demo_ (_demo_@zsnes.com),

-                             Nach,

-                             zsKnight (zsknight@zsnes.com)

-

-  C4 C++ code

-  (c) Copyright 2003 - 2006  Brad Jorsch,

-                             Nach

-

-  DSP-1 emulator code

-  (c) Copyright 1998 - 2006  _Demo_,

-                             Andreas Naive (andreasnaive@gmail.com),

-                             Gary Henderson,

-                             Ivar (ivar@snes9x.com),

-                             John Weidman,

-                             Kris Bleakley,

-                             Matthew Kendora,

-                             Nach,

-                             neviksti (neviksti@hotmail.com)

-

-  DSP-2 emulator code

-  (c) Copyright 2003         John Weidman,

-                             Kris Bleakley,

-                             Lord Nightmare (lord_nightmare@users.sourceforge.net),

-                             Matthew Kendora,

-                             neviksti

-

-  DSP-3 emulator code

-  (c) Copyright 2003 - 2006  John Weidman,

-                             Kris Bleakley,

-                             Lancer,

-                             z80 gaiden

-

-  DSP-4 emulator code

-  (c) Copyright 2004 - 2006  Dreamer Nom,

-                             John Weidman,

-                             Kris Bleakley,

-                             Nach,

-                             z80 gaiden

-

-  OBC1 emulator code

-  (c) Copyright 2001 - 2004  zsKnight,

-                             pagefault (pagefault@zsnes.com),

-                             Kris Bleakley

-                             Ported from x86 assembler to C by sanmaiwashi

-

-  SPC7110 and RTC C++ emulator code used in 1.39-1.51

-  (c) Copyright 2002         Matthew Kendora with research by

-                             zsKnight,

-                             John Weidman,

-                             Dark Force

-

-  SPC7110 and RTC C++ emulator code used in 1.52+

-  (c) Copyright 2009         byuu,

-                             neviksti

-

-  S-DD1 C emulator code

-  (c) Copyright 2003         Brad Jorsch with research by

-                             Andreas Naive,

-                             John Weidman

-

-  S-RTC C emulator code

-  (c) Copyright 2001 - 2006  byuu,

-                             John Weidman

-

-  ST010 C++ emulator code

-  (c) Copyright 2003         Feather,

-                             John Weidman,

-                             Kris Bleakley,

-                             Matthew Kendora

-

-  Super FX x86 assembler emulator code

-  (c) Copyright 1998 - 2003  _Demo_,

-                             pagefault,

-                             zsKnight

-

-  Super FX C emulator code

-  (c) Copyright 1997 - 1999  Ivar,

-                             Gary Henderson,

-                             John Weidman

-

-  Sound emulator code used in 1.5-1.51

-  (c) Copyright 1998 - 2003  Brad Martin

-  (c) Copyright 1998 - 2006  Charles Bilyue'

-

-  Sound emulator code used in 1.52+

-  (c) Copyright 2004 - 2007  Shay Green (gblargg@gmail.com)

-

-  SH assembler code partly based on x86 assembler code

-  (c) Copyright 2002 - 2004  Marcus Comstedt (marcus@mc.pp.se)

-

-  2xSaI filter

-  (c) Copyright 1999 - 2001  Derek Liauw Kie Fa

-

-  HQ2x, HQ3x, HQ4x filters

-  (c) Copyright 2003         Maxim Stepin (maxim@hiend3d.com)

-

-  NTSC filter

-  (c) Copyright 2006 - 2007  Shay Green

-

-  GTK+ GUI code

-  (c) Copyright 2004 - 2011  BearOso

-

-  Win32 GUI code

-  (c) Copyright 2003 - 2006  blip,

-                             funkyass,

-                             Matthew Kendora,

-                             Nach,

-                             nitsuja

-  (c) Copyright 2009 - 2011  OV2

-

-  Mac OS GUI code

-  (c) Copyright 1998 - 2001  John Stiles

-  (c) Copyright 2001 - 2011  zones

-

-

-  Specific ports contains the works of other authors. See headers in

-  individual files.

-

-

-  Snes9x homepage: http://www.snes9x.com/

-

-  Permission to use, copy, modify and/or distribute Snes9x in both binary

-  and source form, for non-commercial purposes, is hereby granted without

-  fee, providing that this license information and copyright notice appear

-  with all copies and any derived work.

-

-  This software is provided 'as-is', without any express or implied

-  warranty. In no event shall the authors be held liable for any damages

-  arising from the use of this software or it's derivatives.

-

-  Snes9x is freeware for PERSONAL USE only. Commercial users should

-  seek permission of the copyright holders first. Commercial use includes,

-  but is not limited to, charging money for Snes9x or software derived from

-  Snes9x, including Snes9x or derivatives in commercial game bundles, and/or

-  using Snes9x as a promotion for your commercial product.

-

-  The copyright holders request that bug fixes and improvements to the code

-  should be forwarded to them so everyone can benefit from the modifications

-  in future versions.

-

-  Super NES and Super Nintendo Entertainment System are trademarks of

-  Nintendo Co., Limited and its subsidiary companies.

- ***********************************************************************************/

+                This file is licensed under the Snes9x License.

+   For further information, consult the LICENSE file in the root directory.

+\*****************************************************************************/

 #pragma once

@@ -291,57 +120,39 @@ inline void ADC16(uint16_t Work16)

 {

 	if (CheckDecimal())

 	{

-		uint16_t A1 = Registers.A.W & 0x000F;

-		uint16_t A2 = Registers.A.W & 0x00F0;

-		uint16_t A3 = Registers.A.W & 0x0F00;

-		uint32_t A4 = Registers.A.W & 0xF000;

-		uint16_t W1 = Work16 & 0x000F;

-		uint16_t W2 = Work16 & 0x00F0;

-		uint16_t W3 = Work16 & 0x0F00;

-		uint16_t W4 = Work16 & 0xF000;

-

-		A1 += W1 + CheckCarry();

-		if (A1 > 0x0009)

-		{

-			A1 -= 0x000A;

-			A1 &= 0x000F;

-			A2 += 0x0010;

-		}

-

-		A2 += W2;

-		if (A2 > 0x0090)

-		{

-			A2 -= 0x00A0;

-			A2 &= 0x00F0;

-			A3 += 0x0100;

-		}

-

-		A3 += W3;

-		if (A3 > 0x0900)

-		{

-			A3 -= 0x0A00;

-			A3 &= 0x0F00;

-			A4 += 0x1000;

-		}

-

-		A4 += W4;

-		if (A4 > 0x9000)

-		{

-			A4 -= 0xA000;

-			A4 &= 0xF000;

-			SetCarry();

-		}

-		else

-			ClearCarry();

+		uint32_t carry = CheckCarry();

+

+		uint32_t result = (Registers.A.W & 0x000F) + (Work16 & 0x000F) + carry;

+		if (result > 0x0009)

+			result += 0x0006;

+		carry = result > 0x000F;

+

+		result = (Registers.A.W & 0x00F0) + (Work16 & 0x00F0) + (result & 0x000F) + carry * 0x10;

+		if (result > 0x009F)

+			result += 0x0060;

+		carry = result > 0x00FF;

-		uint16_t Ans16 = A4 | A3 | A2 | A1;

+		result = (Registers.A.W & 0x0F00) + (Work16 & 0x0F00) + (result & 0x00FF) + carry * 0x100;

+		if (result > 0x09FF)

+			result += 0x0600;

+		carry = result > 0x0FFF;

-		if (~(Registers.A.W ^ Work16) & (Work16 ^ Ans16) & 0x8000)

+		result = (Registers.A.W & 0xF000) + (Work16 & 0xF000) + (result & 0x0FFF) + carry * 0x1000;

+

+		if ((Registers.A.W & 0x8000) == (Work16 & 0x8000) && (Registers.A.W & 0x8000) != (result & 0x8000))

 			SetOverflow();

 		else

 			ClearOverflow();

-		Registers.A.W = Ans16;

+		if (result > 0x9FFF)

+			result += 0x6000;

+

+		if (result > 0xFFFF)

+			SetCarry();

+		else

+			ClearCarry();

+

+		Registers.A.W = result & 0xFFFF;

 		SetZN(Registers.A.W);

 	}

 	else

@@ -364,37 +175,29 @@ inline void ADC8(uint8_t Work8)

 {

 	if (CheckDecimal())

 	{

-		uint8_t A1 = Registers.A.W & 0x0F;

-		uint16_t A2 = Registers.A.W & 0xF0;

-		uint8_t W1 = Work8 & 0x0F;

-		uint8_t W2 = Work8 & 0xF0;

-

-		A1 += W1 + CheckCarry();

-		if (A1 > 0x09)

-		{

-			A1 -= 0x0A;

-			A1 &= 0x0F;

-			A2 += 0x10;

-		}

-

-		A2 += W2;

-		if (A2 > 0x90)

-		{

-			A2 -= 0xA0;

-			A2 &= 0xF0;

-			SetCarry();

-		}

-		else

-			ClearCarry();

+		uint32_t carry = CheckCarry();

-		uint8_t Ans8 = A2 | A1;

+		uint32_t result = (Registers.A.B.l & 0x0F) + (Work8 & 0x0F) + carry;

+		if (result > 0x09)

+			result += 0x06;

+		carry = result > 0x0F;

-		if (~(Registers.A.B.l ^ Work8) & (Work8 ^ Ans8) & 0x80)

+		result = (Registers.A.B.l & 0xF0) + (Work8 & 0xF0) + (result & 0x0F) + (carry * 0x10);

+

+		if ((Registers.A.B.l & 0x80) == (Work8 & 0x80) && (Registers.A.B.l & 0x80) != (result & 0x80))

 			SetOverflow();

 		else

 			ClearOverflow();

-		Registers.A.B.l = Ans8;

+		if (result > 0x9F)

+			result += 0x60;

+

+		if (result > 0xFF)

+			SetCarry();

+		else

+			ClearCarry();

+

+		Registers.A.B.l = result & 0xFF;

 		SetZN(Registers.A.B.l);

 	}

 	else

@@ -667,58 +470,41 @@ inline void SBC16(uint16_t Work16)

 {

 	if (CheckDecimal())

 	{

-		uint16_t A1 = Registers.A.W & 0x000F;

-		uint16_t A2 = Registers.A.W & 0x00F0;

-		uint16_t A3 = Registers.A.W & 0x0F00;

-		uint32_t A4 = Registers.A.W & 0xF000;

-		uint16_t W1 = Work16 & 0x000F;

-		uint16_t W2 = Work16 & 0x00F0;

-		uint16_t W3 = Work16 & 0x0F00;

-		uint16_t W4 = Work16 & 0xF000;

-

-		A1 -= W1 + !CheckCarry();

-		A2 -= W2;

-		A3 -= W3;

-		A4 -= W4;

-

-		if (A1 > 0x000F)

-		{

-			A1 += 0x000A;

-			A1 &= 0x000F;

-			A2 -= 0x0010;

-		}

-

-		if (A2 > 0x00F0)

-		{

-			A2 += 0x00A0;

-			A2 &= 0x00F0;

-			A3 -= 0x0100;

-		}

-

-		if (A3 > 0x0F00)

-		{

-			A3 += 0x0A00;

-			A3 &= 0x0F00;

-			A4 -= 0x1000;

-		}

-

-		if (A4 > 0xF000)

-		{

-			A4 += 0xA000;

-			A4 &= 0xF000;

-			ClearCarry();

-		}

-		else

-			SetCarry();

+		int carry = CheckCarry();

+

+		Work16 ^= 0xFFFF;

+

+		int result = (Registers.A.W & 0x000F) + (Work16 & 0x000F) + carry;

+		if (result < 0x0010)

+			result -= 0x0006;

+		carry = result > 0x000F;

+

+		result = (Registers.A.W & 0x00F0) + (Work16 & 0x00F0) + (result & 0x000F) + carry * 0x10;

+		if (result < 0x0100)

+			result -= 0x0060;

+		carry = result > 0x00FF;

-		uint16_t Ans16 = A4 | A3 | A2 | A1;

+		result = (Registers.A.W & 0x0F00) + (Work16 & 0x0F00) + (result & 0x00FF) + carry * 0x100;

+		if (result < 0x1000)

+			result -= 0x0600;

+		carry = result > 0x0FFF;

-		if ((Registers.A.W ^ Work16) & (Registers.A.W ^ Ans16) & 0x8000)

+		result = (Registers.A.W & 0xF000) + (Work16 & 0xF000) + (result & 0x0FFF) + carry * 0x1000;

+

+		if (!((Registers.A.W ^ Work16) & 0x8000) && ((Registers.A.W ^ result) & 0x8000))

 			SetOverflow();

 		else

 			ClearOverflow();

-		Registers.A.W = Ans16;

+		if (result < 0x10000)

+			result -= 0x6000;

+

+		if (result > 0xFFFF)

+			SetCarry();

+		else

+			ClearCarry();

+

+		Registers.A.W = result & 0xFFFF;

 		SetZN(Registers.A.W);

 	}

 	else

@@ -741,38 +527,31 @@ inline void SBC8(uint8_t Work8)

 {

 	if (CheckDecimal())

 	{

-		uint8_t A1 = Registers.A.W & 0x0F;

-		uint16_t A2 = Registers.A.W & 0xF0;

-		uint8_t W1 = Work8 & 0x0F;

-		uint8_t W2 = Work8 & 0xF0;

-

-		A1 -= W1 + !CheckCarry();

-		A2 -= W2;

-

-		if (A1 > 0x0F)

-		{

-			A1 += 0x0A;

-			A1 &= 0x0F;

-			A2 -= 0x10;

-		}

-

-		if (A2 > 0xF0)

-		{

-			A2 += 0xA0;

-			A2 &= 0xF0;

-			ClearCarry();

-		}

-		else

-			SetCarry();

+		int carry = CheckCarry();

+

+		Work8 ^= 0xFF;

-		uint8_t Ans8 = A2 | A1;

+		int result = (Registers.A.B.l & 0x0F) + (Work8 & 0x0F) + carry;

+		if (result < 0x10)

+			result -= 0x06;

+		carry = (result > 0x0F);

-		if ((Registers.A.B.l ^ Work8) & (Registers.A.B.l ^ Ans8) & 0x80)

+		result = (Registers.A.B.l & 0xF0) + (Work8 & 0xF0) + (result & 0x0F) + carry * 0x10;

+

+		if ((Registers.A.B.l & 0x80) == (Work8 & 0x80) && (Registers.A.B.l & 0x80) != (result & 0x80))

 			SetOverflow();

 		else

 			ClearOverflow();

-		Registers.A.B.l = Ans8;

+		if (result < 0x100)

+			result -= 0x60;

+

+		if (result > 0xFF)

+			SetCarry();

+		else

+			ClearCarry();

+

+		Registers.A.B.l = result & 0xFF;

 		SetZN(Registers.A.B.l);

 	}

 	else

@@ -175,8 +175,7 @@

   Nintendo Co., Limited and its subsidiary companies.

  ***********************************************************************************/

-#ifndef _CPUMACRO_H_

-#define _CPUMACRO_H_

+#pragma once

 template<typename Fa, typename Ff> inline void rOP8(Fa addr, Ff func)

 {

@@ -879,5 +878,3 @@ inline void TSB8(uint32_t OpAddress)

 	S9xSetByte(Work8, OpAddress);

 	OpenBus = Work8;

 }

-

-#endif

@@ -175,140 +175,131 @@

   Nintendo Co., Limited and its subsidiary companies.

  ***********************************************************************************/

-

 #ifndef _CPUMACRO_H_

 #define _CPUMACRO_H_

-#define rOP8(OP, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	uint8_t	val = OpenBus = S9xGetByte(ADDR(READ)); \

-	FUNC(val); \

+template<typename Fa, typename Ff> inline void rOP8(Fa addr, Ff func)

+{

+	uint8_t val = OpenBus = S9xGetByte(addr(READ));

+	func(val);

 }

-#define rOP16(OP, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	uint16_t	val = S9xGetWord(ADDR(READ), WRAP); \

-	OpenBus = (uint8_t) (val >> 8); \

-	FUNC(val); \

+template<typename Fa, typename Ff> inline void rOP16(Fa addr, Ff func, s9xwrap_t wrap = WRAP_NONE)

+{

+	uint16_t val = S9xGetWord(addr(READ), wrap);

+	OpenBus = static_cast<uint8_t>(val >> 8);

+	func(val);

 }

-#define rOPC(OP, COND, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	if (Check##COND()) \

-	{ \

-		uint8_t	val = OpenBus = S9xGetByte(ADDR(READ)); \

-		FUNC(val); \

-	} \

-	else \

-	{ \

-		uint16_t	val = S9xGetWord(ADDR(READ), WRAP); \

-		OpenBus = (uint8_t) (val >> 8); \

-		FUNC(val); \

-	} \

+template<typename Fa, typename Ff8, typename Ff16> inline void rOPC(bool cond, Fa addr, Ff8 func8, Ff16 func16, s9xwrap_t wrap = WRAP_NONE)

+{

+	if (cond)

+		rOP8(addr, func8);

+	else

+		rOP16(addr, func16, wrap);

 }

-#define rOPM(OP, ADDR, WRAP, FUNC) \

-rOPC(OP, Memory, ADDR, WRAP, FUNC)

-

-#define rOPX(OP, ADDR, WRAP, FUNC) \

-rOPC(OP, Index, ADDR, WRAP, FUNC)

+template<typename Fa, typename Ff8, typename Ff16> inline void rOPM(Fa addr, Ff8 func8, Ff16 func16, s9xwrap_t wrap = WRAP_NONE)

+{

+	rOPC(CheckMemory(), addr, func8, func16, wrap);

+}

-#define wOP8(OP, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	FUNC##8(ADDR(WRITE)); \

+template<typename Fa, typename Ff8, typename Ff16> inline void rOPX(Fa addr, Ff8 func8, Ff16 func16, s9xwrap_t wrap = WRAP_NONE)

+{

+	rOPC(CheckIndex(), addr, func8, func16, wrap);

 }

-#define wOP16(OP, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	FUNC##16(ADDR(WRITE), WRAP); \

+template<typename Fa, typename Ff> inline void wOP8(Fa addr, Ff func)

+{

+	func(addr(WRITE));

 }

-#define wOPC(OP, COND, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	if (Check##COND()) \

-		FUNC##8(ADDR(WRITE)); \

-	else \

-		FUNC##16(ADDR(WRITE), WRAP); \

+template<typename Fa, typename Ff> inline void wOP16(Fa addr, Ff func, s9xwrap_t wrap = WRAP_NONE)

+{

+	func(addr(WRITE), wrap);

 }

-#define wOPM(OP, ADDR, WRAP, FUNC) \

-wOPC(OP, Memory, ADDR, WRAP, FUNC)

+template<typename Fa, typename Ff8, typename Ff16> inline void wOPC(bool cond, Fa addr, Ff8 func8, Ff16 func16, s9xwrap_t wrap = WRAP_NONE)

+{

+	if (cond)

+		wOP8(addr, func8);

+	else

+		wOP16(addr, func16, wrap);

+}

-#define wOPX(OP, ADDR, WRAP, FUNC) \

-wOPC(OP, Index, ADDR, WRAP, FUNC)

+template<typename Fa, typename Ff8, typename Ff16> inline void wOPM(Fa addr, Ff8 func8, Ff16 func16, s9xwrap_t wrap = WRAP_NONE)

+{

+	wOPC(CheckMemory(), addr, func8, func16, wrap);

+}

-#define mOP8(OP, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	FUNC##8(ADDR(MODIFY)); \

+template<typename Fa, typename Ff8, typename Ff16> inline void wOPX(Fa addr, Ff8 func8, Ff16 func16, s9xwrap_t wrap = WRAP_NONE)

+{

+	wOPC(CheckIndex(), addr, func8, func16, wrap);

 }

-#define mOP16(OP, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	FUNC##16(ADDR(MODIFY), WRAP); \

+template<typename Fa, typename Ff> inline void mOP8(Fa addr, Ff func)

+{

+	func(addr(MODIFY));

 }

-#define mOPC(OP, COND, ADDR, WRAP, FUNC) \

-static void Op##OP() \

-{ \

-	if (Check##COND()) \

-		FUNC##8(ADDR(MODIFY)); \

-	else \

-		FUNC##16(ADDR(MODIFY), WRAP); \

+template<typename Fa, typename Ff> inline void mOP16(Fa addr, Ff func, s9xwrap_t wrap = WRAP_NONE)

+{

+	func(addr(MODIFY), wrap);

 }

-#define mOPM(OP, ADDR, WRAP, FUNC) \

-mOPC(OP, Memory, ADDR, WRAP, FUNC)

+template<typename Fa, typename Ff8, typename Ff16> inline void mOPC(bool cond, Fa addr, Ff8 func8, Ff16 func16, s9xwrap_t wrap = WRAP_NONE)

+{

+	if (cond)

+		mOP8(addr, func8);

+	else

+		mOP16(addr, func16, wrap);

+}

-#define bOP(OP, REL, COND, CHK, E) \

-static void Op##OP() \

-{ \

-	pair	newPC; \

-	newPC.W = REL(JUMP); \

-	if (COND) \

-	{ \

-		AddCycles(ONE_CYCLE); \

-		if (E && Registers.PCh != newPC.B.h) \

-			AddCycles(ONE_CYCLE); \

-		if ((Registers.PCw & ~MEMMAP_MASK) != (newPC.W & ~MEMMAP_MASK)) \

-			S9xSetPCBase(ICPU.ShiftedPB + newPC.W); \

-		else \

-			Registers.PCw = newPC.W; \

-	} \

+template<typename Fa, typename Ff8, typename Ff16> inline void mOPM(Fa addr, Ff8 func8, Ff16 func16, s9xwrap_t wrap = WRAP_NONE)

+{

+	mOPC(CheckMemory(), addr, func8, func16, wrap);

 }

+template<typename F> inline void bOP(F rel, bool cond, bool e)

+{

+	pair newPC;

+	newPC.W = rel(JUMP);

+	if (cond)

+	{

+		AddCycles(ONE_CYCLE);

+		if (e && Registers.PC.B.xPCh != newPC.B.h)

+			AddCycles(ONE_CYCLE);

+		if ((Registers.PC.W.xPC & ~MEMMAP_MASK) != (newPC.W & ~MEMMAP_MASK))

+			S9xSetPCBase(ICPU.ShiftedPB + newPC.W);

+		else

+			Registers.PC.W.xPC = newPC.W;

+	}

+}

-static inline void SetZN (uint16_t Work16)

+inline void SetZN(uint16_t Work16)

 {

-	ICPU._Zero = Work16 != 0;

-	ICPU._Negative = (uint8_t) (Work16 >> 8);

+	ICPU._Zero = !!Work16;

+	ICPU._Negative = static_cast<uint8_t>(Work16 >> 8);

 }

-static inline void SetZN (uint8_t Work8)

+inline void SetZN(uint8_t Work8)

 {

 	ICPU._Zero = Work8;

 	ICPU._Negative = Work8;

 }

-static inline void ADC (uint16_t Work16)

+inline void ADC16(uint16_t Work16)

 {

 	if (CheckDecimal())

 	{

-		uint16_t	A1 = Registers.A.W & 0x000F;

-		uint16_t	A2 = Registers.A.W & 0x00F0;

-		uint16_t	A3 = Registers.A.W & 0x0F00;

-		uint32_t	A4 = Registers.A.W & 0xF000;

-		uint16_t	W1 = Work16 & 0x000F;

-		uint16_t	W2 = Work16 & 0x00F0;

-		uint16_t	W3 = Work16 & 0x0F00;

-		uint16_t	W4 = Work16 & 0xF000;

+		uint16_t A1 = Registers.A.W & 0x000F;

+		uint16_t A2 = Registers.A.W & 0x00F0;

+		uint16_t A3 = Registers.A.W & 0x0F00;

+		uint32_t A4 = Registers.A.W & 0xF000;

+		uint16_t W1 = Work16 & 0x000F;

+		uint16_t W2 = Work16 & 0x00F0;

+		uint16_t W3 = Work16 & 0x0F00;

+		uint16_t W4 = Work16 & 0xF000;

 		A1 += W1 + CheckCarry();

 		if (A1 > 0x0009)

@@ -344,7 +335,7 @@ static inline void ADC (uint16_t Work16)

 		else

 			ClearCarry();

-		uint16_t	Ans16 = A4 | A3 | A2 | A1;

+		uint16_t Ans16 = A4 | A3 | A2 | A1;

 		if (~(Registers.A.W ^ Work16) & (Work16 ^ Ans16) & 0x8000)

 			SetOverflow();

@@ -356,28 +347,28 @@ static inline void ADC (uint16_t Work16)

 	}

 	else

 	{

-		uint32_t	Ans32 = Registers.A.W + Work16 + CheckCarry();

+		uint32_t Ans32 = Registers.A.W + Work16 + CheckCarry();

 		ICPU._Carry = Ans32 >= 0x10000;

-		if (~(Registers.A.W ^ Work16) & (Work16 ^ (uint16_t) Ans32) & 0x8000)

+		if (~(Registers.A.W ^ Work16) & (Work16 ^ static_cast<uint16_t>(Ans32)) & 0x8000)

 			SetOverflow();

 		else

 			ClearOverflow();

-		Registers.A.W = (uint16_t) Ans32;

+		Registers.A.W = static_cast<uint16_t>(Ans32);

 		SetZN(Registers.A.W);

 	}

 }

-static inline void ADC (uint8_t Work8)

+inline void ADC8(uint8_t Work8)

 {

 	if (CheckDecimal())

 	{

-		uint8_t	A1 = Registers.A.W & 0x0F;

-		uint16_t	A2 = Registers.A.W & 0xF0;

-		uint8_t	W1 = Work8 & 0x0F;

-		uint8_t	W2 = Work8 & 0xF0;

+		uint8_t A1 = Registers.A.W & 0x0F;

+		uint16_t A2 = Registers.A.W & 0xF0;

+		uint8_t W1 = Work8 & 0x0F;

+		uint8_t W2 = Work8 & 0xF0;

 		A1 += W1 + CheckCarry();

 		if (A1 > 0x09)

@@ -397,48 +388,48 @@ static inline void ADC (uint8_t Work8)

 		else

 			ClearCarry();

-		uint8_t	Ans8 = A2 | A1;

+		uint8_t Ans8 = A2 | A1;

-		if (~(Registers.AL ^ Work8) & (Work8 ^ Ans8) & 0x80)

+		if (~(Registers.A.B.l ^ Work8) & (Work8 ^ Ans8) & 0x80)

 			SetOverflow();

 		else

 			ClearOverflow();

-		Registers.AL = Ans8;

-		SetZN(Registers.AL);

+		Registers.A.B.l = Ans8;

+		SetZN(Registers.A.B.l);

 	}

 	else

 	{

-		uint16_t	Ans16 = Registers.AL + Work8 + CheckCarry();

+		uint16_t Ans16 = Registers.A.B.l + Work8 + CheckCarry();

 		ICPU._Carry = Ans16 >= 0x100;

-		if (~(Registers.AL ^ Work8) & (Work8 ^ (uint8_t) Ans16) & 0x80)

+		if (~(Registers.A.B.l ^ Work8) & (Work8 ^ static_cast<uint8_t>(Ans16)) & 0x80)

 			SetOverflow();

 		else

 			ClearOverflow();

-		Registers.AL = (uint8_t) Ans16;

-		SetZN(Registers.AL);

+		Registers.A.B.l = static_cast<uint8_t>(Ans16);

+		SetZN(Registers.A.B.l);

 	}

 }

-static inline void AND (uint16_t Work16)

+inline void AND16(uint16_t Work16)

 {

 	Registers.A.W &= Work16;

 	SetZN(Registers.A.W);

 }

-static inline void AND (uint8_t Work8)

+inline void AND8(uint8_t Work8)

 {

-	Registers.AL &= Work8;

-	SetZN(Registers.AL);

+	Registers.A.B.l &= Work8;

+	SetZN(Registers.A.B.l);

 }

-static inline void ASL16 (uint32_t OpAddress, s9xwrap_t w)

+inline void ASL16(uint32_t OpAddress, s9xwrap_t w)

 {

-	uint16_t	Work16 = S9xGetWord(OpAddress, w);

-	ICPU._Carry = (Work16 & 0x8000) != 0;

+	uint16_t Work16 = S9xGetWord(OpAddress, w);

+	ICPU._Carry = !!(Work16 & 0x8000);

 	Work16 <<= 1;

 	AddCycles(ONE_CYCLE);

 	S9xSetWord(Work16, OpAddress, w, WRITE_10);

@@ -446,10 +437,10 @@ static inline void ASL16 (uint32_t OpAddress, s9xwrap_t w)

 	SetZN(Work16);

 }

-static inline void ASL8 (uint32_t OpAddress)

+inline void ASL8(uint32_t OpAddress)

 {

-	uint8_t	Work8 = S9xGetByte(OpAddress);

-	ICPU._Carry = (Work8 & 0x80) != 0;

+	uint8_t Work8 = S9xGetByte(OpAddress);

+	ICPU._Carry = !!(Work8 & 0x80);

 	Work8 <<= 1;

 	AddCycles(ONE_CYCLE);

 	S9xSetByte(Work8, OpAddress);

@@ -457,149 +448,149 @@ static inline void ASL8 (uint32_t OpAddress)

 	SetZN(Work8);

 }

-static inline void BIT (uint16_t Work16)

+inline void BIT16(uint16_t Work16)

 {

-	ICPU._Overflow = (Work16 & 0x4000) != 0;

-	ICPU._Negative = (uint8_t) (Work16 >> 8);

-	ICPU._Zero = (Work16 & Registers.A.W) != 0;

+	ICPU._Overflow = !!(Work16 & 0x4000);

+	ICPU._Negative = static_cast<uint8_t>(Work16 >> 8);

+	ICPU._Zero = !!(Work16 & Registers.A.W);

 }

-static inline void BIT (uint8_t Work8)

+inline void BIT8(uint8_t Work8)

 {

-	ICPU._Overflow = (Work8 & 0x40) != 0;

+	ICPU._Overflow = !!(Work8 & 0x40);

 	ICPU._Negative = Work8;

-	ICPU._Zero = Work8 & Registers.AL;

+	ICPU._Zero = !!(Work8 & Registers.A.B.l);

 }

-static inline void CMP (uint16_t val)

+inline void CMP16(uint16_t val)

 {

-	int32_t	Int32 = (int32_t) Registers.A.W - (int32_t) val;

+	int32_t Int32 = static_cast<int32_t>(Registers.A.W) - static_cast<int32_t>(val);

 	ICPU._Carry = Int32 >= 0;

-	SetZN((uint16_t) Int32);

+	SetZN(static_cast<uint16_t>(Int32));

 }

-static inline void CMP (uint8_t val)

+inline void CMP8(uint8_t val)

 {

-	int16_t	Int16 = (int16_t) Registers.AL - (int16_t) val;

+	int16_t Int16 = static_cast<int16_t>(Registers.A.B.l) - static_cast<int16_t>(val);

 	ICPU._Carry = Int16 >= 0;

-	SetZN((uint8_t) Int16);

+	SetZN(static_cast<uint8_t>(Int16));