From 7b03fc0bc057ff1a74f794d40a4691ca44903234 Mon Sep 17 00:00:00 2001
From: adelikat <adelikat@tasvideos.org>
Date: Mon, 4 Nov 2013 00:36:15 +0000
Subject: [PATCH] Move Buffer.cs and Util.cs from BizHawk.Emulation to
 BizHawk.Common, and add 1234832983 usings

---
 BizHawk.Client.Common/ControllerBinding.cs    |    2 +
 BizHawk.Client.Common/FirmwareManager.cs      |    2 +
 BizHawk.Client.Common/movie/MovieMnemonics.cs |    2 +
 .../DisplayManager/DisplayManager.cs          |    1 +
 BizHawk.Client.EmuHawk/Input/Input.cs         |    1 +
 BizHawk.Common/BizHawk.Common.csproj          |    2 +
 .../Buffer.cs                                 |    2 +-
 BizHawk.Common/Util.String.cs                 |    8 +
 BizHawk.Common/Util.cs                        |  924 ++++-
 .../BizHawk.Emulation.DiscSystem.csproj       |    1 -
 BizHawk.Emulation.DiscSystem/Buffer.cs        |  118 -
 BizHawk.Emulation.DiscSystem/Disc.API.cs      |    2 +
 BizHawk.Emulation.DiscSystem/ECM.cs           |    2 +
 BizHawk.Emulation.DiscSystem/Util.cs          |    7 +-
 BizHawk.Emulation/BizHawk.Emulation.csproj    |    2 -
 BizHawk.Emulation/CPUs/MOS 6502X/MOS6502X.cs  |    2 +
 .../CPUs/MOS 6502X/MOS6502XDouble.cs          |    2 +
 .../CPUs/MOS 6502X/MOS6502XNative.cs          |    2 +
 .../Computers/Commodore64/C64.Motherboard.cs  |  214 +-
 .../Computers/Commodore64/C64.Savestate.cs    |   10 +-
 .../Computers/Commodore64/Cartridge/Cart.cs   |    4 +-
 .../Commodore64/Cartridge/Mapper0005.cs       |    2 +
 .../Commodore64/Cartridge/Mapper000F.cs       |    2 +
 .../Commodore64/Cartridge/Mapper0012.cs       |    2 +
 .../Commodore64/Cartridge/Mapper0013.cs       |    1 +
 .../Commodore64/Cartridge/Mapper0020.cs       |    1 +
 .../Experimental/Chips/Internals/Cassette.cs  |   22 +-
 .../Chips/Internals/Cia.Interface.cs          |   48 +-
 .../Chips/Internals/Cpu.Interface.cs          |   60 +-
 .../Experimental/Chips/Internals/Expansion.cs |   26 +-
 .../Experimental/Chips/Internals/Joystick.cs  |   18 +-
 .../Experimental/Chips/Internals/Keyboard.cs  |   22 +-
 .../Experimental/Chips/Internals/Ram.cs       |   60 +-
 .../Experimental/Chips/Internals/Rom.cs       |   44 +-
 .../Experimental/Chips/Internals/Serial.cs    |   30 +-
 .../Chips/Internals/Sid.Interface.cs          |   10 +-
 .../Experimental/Chips/Internals/Vic.State.cs |   14 +-
 .../Chips/Internals/Vic.VideoProvider.cs      |   58 +-
 .../Commodore64/MOS/CartridgePort.cs          |   38 +-
 .../Computers/Commodore64/MOS/CassettePort.cs |   29 +-
 .../Computers/Commodore64/MOS/Chip2114.cs     |   18 +-
 .../Computers/Commodore64/MOS/Chip23XX.cs     |    3 +-
 .../Computers/Commodore64/MOS/Chip4864.cs     |   20 +-
 .../Computers/Commodore64/MOS/MOS6510.cs      |  114 +-
 .../Computers/Commodore64/MOS/MOS6526.cs      |    1 +
 .../Computers/Commodore64/MOS/MOSPLA.cs       |    1 +
 .../Computers/Commodore64/MOS/Port.cs         |  131 +-
 .../Computers/Commodore64/MOS/SerialPort.cs   |   31 +-
 .../Computers/Commodore64/MOS/Sid.Envelope.cs |  408 +-
 .../Computers/Commodore64/MOS/Sid.Voice.cs    |  598 +--
 .../Computers/Commodore64/MOS/Sid.cs          |    1 +
 .../Computers/Commodore64/MOS/UserPort.cs     |   95 +-
 .../Commodore64/MOS/Vic.SpriteGenerator.cs    |  108 +-
 .../Computers/Commodore64/MOS/Vic.State.cs    |  342 +-
 .../Commodore64/MOS/Vic.VideoProvider.cs      |   11 +-
 .../Consoles/Atari/2600/Atari2600.Core.cs     |    2 +
 .../Consoles/Atari/2600/Atari2600.cs          |    2 +
 .../Consoles/Atari/2600/M6532.cs              |    4 +-
 .../Consoles/Atari/2600/Mappers/m3E.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/m3F.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/m4A50.cs      |    4 +-
 .../Consoles/Atari/2600/Mappers/mCV.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mDPC.cs       |    4 +-
 .../Consoles/Atari/2600/Mappers/mE0.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mE7.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mEF.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mF0.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mF4.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mF6.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mF8.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mFA.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mUA.cs        |    4 +-
 .../Consoles/Atari/2600/Mappers/mX07.cs       |    4 +-
 BizHawk.Emulation/Consoles/Atari/2600/TIA.cs  |    2 +
 .../Consoles/Atari/7800/Atari7800.cs          |    2 +
 .../Consoles/Nintendo/NES/BisqAPU.cs          |    1 +
 .../Consoles/Nintendo/NES/BoardSystem.cs      |    2 +
 .../Consoles/Nintendo/NES/Boards/AVE-NINA.cs  |    4 +-
 .../Consoles/Nintendo/NES/Boards/AxROM.cs     |    2 +
 .../NES/Boards/BANDAI_74_161_02_74.cs         |    4 +-
 .../NES/Boards/BANDAI_74_161_161_32.cs        |    4 +-
 .../Consoles/Nintendo/NES/Boards/BxROM.cs     |    4 +-
 .../Consoles/Nintendo/NES/Boards/CNROM.cs     |    1 +
 .../Consoles/Nintendo/NES/Boards/CPROM.cs     |    5 +-
 .../Consoles/Nintendo/NES/Boards/ExROM.cs     |    2 +-
 .../Consoles/Nintendo/NES/Boards/GxROM.cs     |    1 +
 .../Consoles/Nintendo/NES/Boards/IC_74x377.cs |    1 +
 .../NES/Boards/IREM-74_161_161_21_138.cs      |    4 +-
 .../Nintendo/NES/Boards/IREM_TAM_S1.cs        |    4 +-
 .../Consoles/Nintendo/NES/Boards/Irem_G101.cs |    4 +-
 .../Nintendo/NES/Boards/Irem_H3001.cs         |    4 +-
 .../Nintendo/NES/Boards/JALECO_JF_13.cs       |    4 +-
 .../Nintendo/NES/Boards/JALECO_JF_17.cs       |    4 +-
 .../Nintendo/NES/Boards/JALECO_SS8806.cs      |    4 +-
 .../Nintendo/NES/Boards/Jaleco-JF_11_14.cs    |    4 +-
 .../NES/Boards/MMC3_family/Mapper012.cs       |    4 +-
 .../NES/Boards/MMC3_family/Mapper037.cs       |    4 +-
 .../NES/Boards/MMC3_family/Mapper044.cs       |    4 +-
 .../NES/Boards/MMC3_family/Mapper165.cs       |    4 +-
 .../NES/Boards/MMC3_family/Mapper189.cs       |    4 +-
 .../NES/Boards/MMC3_family/Mapper205.cs       |    4 +-
 .../Nintendo/NES/Boards/MMC3_family/NES-QJ.cs |    2 +
 .../Nintendo/NES/Boards/MMC3_family/TxROM.cs  |    2 +
 .../Consoles/Nintendo/NES/Boards/Mapper028.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper036.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper038.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper040.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper041.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper042.cs |    1 +
 .../Consoles/Nintendo/NES/Boards/Mapper046.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper091.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper101.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper103.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper107.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper108.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper120.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper132.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper156.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper164.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper168.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper177.cs |    6 +-
 .../Consoles/Nintendo/NES/Boards/Mapper180.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper193.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper201.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper203.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper240.cs |    1 +
 .../Consoles/Nintendo/NES/Boards/Mapper241.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper243.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper246.cs |    4 +-
 .../Consoles/Nintendo/NES/Boards/Mapper60.cs  |    4 +-
 .../NES/Boards/Namcot1xx/Mapper112.cs         |    4 +-
 .../NES/Boards/Namcot1xx/Namco163Audio.cs     |    1 +
 .../NES/Boards/Namcot1xx/Namcot1xx.cs         |    1 +
 .../Consoles/Nintendo/NES/Boards/NanJing.cs   |    4 +-
 .../Nintendo/NES/Boards/NovelDiamond.cs       |    4 +-
 .../Nintendo/NES/Boards/SachenSimple.cs       |    1 +
 .../Consoles/Nintendo/NES/Boards/Sunsoft1.cs  |    4 +-
 .../Consoles/Nintendo/NES/Boards/Sunsoft4.cs  |    4 +-
 .../Consoles/Nintendo/NES/Boards/SxROM.cs     |    1 +
 .../Nintendo/NES/Boards/TENGEN_800008.cs      |    4 +-
 .../Nintendo/NES/Boards/Taito_TC0190FMC.cs    |    4 +-
 .../Consoles/Nintendo/NES/Boards/UxROM.cs     |    1 +
 .../Consoles/Nintendo/NES/Core.cs             |    2 +
 .../Consoles/Nintendo/NES/FDS/FDS.cs          |    1 +
 .../Consoles/Nintendo/NES/FDS/FDSAudio.cs     |    1 +
 .../Consoles/Nintendo/NES/FDS/RamAdapter.cs   |    2 +
 .../Consoles/Nintendo/NES/NES.cs              |    1 +
 .../Consoles/Nintendo/NES/PPU.cs              |    2 +-
 .../Consoles/Nintendo/NES/PPU.run.cs          |    2 +
 .../Consoles/Nintendo/NES/Unif.cs             |    2 +
 .../Consoles/Nintendo/NES/iNES.cs             |    1 +
 BizHawk.Emulation/Database/Database.cs        |    2 +
 .../Base Implementations/NullEmulator.cs      |    1 +
 BizHawk.Emulation/Sound/YM2413.cs             | 3338 +++++++++--------
 BizHawk.Emulation/Util.cs                     |  922 -----
 155 files changed, 4194 insertions(+), 4062 deletions(-)
 rename {BizHawk.Emulation => BizHawk.Common}/Buffer.cs (95%)
 create mode 100644 BizHawk.Common/Util.String.cs
 delete mode 100644 BizHawk.Emulation.DiscSystem/Buffer.cs
 delete mode 100644 BizHawk.Emulation/Util.cs

diff --git a/BizHawk.Client.Common/ControllerBinding.cs b/BizHawk.Client.Common/ControllerBinding.cs
index 672d3bfc24..5984dc104b 100644
--- a/BizHawk.Client.Common/ControllerBinding.cs
+++ b/BizHawk.Client.Common/ControllerBinding.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 
+using BizHawk.Common;
+
 namespace BizHawk.Client.Common
 {
 	public class Controller : IController
diff --git a/BizHawk.Client.Common/FirmwareManager.cs b/BizHawk.Client.Common/FirmwareManager.cs
index fbdc27d7df..b173cdddb9 100644
--- a/BizHawk.Client.Common/FirmwareManager.cs
+++ b/BizHawk.Client.Common/FirmwareManager.cs
@@ -2,6 +2,8 @@
 using System.IO;
 using System.Collections.Generic;
 
+using BizHawk.Common;
+
 //IDEA: put filesizes in DB too. then scans can go real quick by only scanning filesizes that match (and then scanning filesizes that dont match, in case of an emergency)
 //this would be adviseable if we end up with a very large firmware file
 
diff --git a/BizHawk.Client.Common/movie/MovieMnemonics.cs b/BizHawk.Client.Common/movie/MovieMnemonics.cs
index 456f5591dc..dc18760c88 100644
--- a/BizHawk.Client.Common/movie/MovieMnemonics.cs
+++ b/BizHawk.Client.Common/movie/MovieMnemonics.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Client.Common
 {
 	public static class MnemonicConstants
diff --git a/BizHawk.Client.EmuHawk/DisplayManager/DisplayManager.cs b/BizHawk.Client.EmuHawk/DisplayManager/DisplayManager.cs
index 07b753848e..801f6ce2c9 100644
--- a/BizHawk.Client.EmuHawk/DisplayManager/DisplayManager.cs
+++ b/BizHawk.Client.EmuHawk/DisplayManager/DisplayManager.cs
@@ -12,6 +12,7 @@ using System.Drawing.Imaging;
 //using dx=SlimDX;
 //using d3d=SlimDX.Direct3D9;
 
+using BizHawk.Common;
 using BizHawk.Client.Common;
 
 namespace BizHawk.Client.EmuHawk
diff --git a/BizHawk.Client.EmuHawk/Input/Input.cs b/BizHawk.Client.EmuHawk/Input/Input.cs
index 31c74973ec..617b95afa8 100644
--- a/BizHawk.Client.EmuHawk/Input/Input.cs
+++ b/BizHawk.Client.EmuHawk/Input/Input.cs
@@ -6,6 +6,7 @@ using System.Threading;
 using SlimDX.DirectInput;
 #endif
 
+using BizHawk.Common;
 using BizHawk.Client.Common;
 
 namespace BizHawk.Client.EmuHawk
diff --git a/BizHawk.Common/BizHawk.Common.csproj b/BizHawk.Common/BizHawk.Common.csproj
index 5892641d8a..4da9a96e5e 100644
--- a/BizHawk.Common/BizHawk.Common.csproj
+++ b/BizHawk.Common/BizHawk.Common.csproj
@@ -44,6 +44,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Buffer.cs" />
     <Compile Include="Extensions.cs" />
     <Compile Include="HawkFile.cs" />
     <Compile Include="MruStack.cs" />
@@ -51,6 +52,7 @@
     <Compile Include="Types.cs" />
     <Compile Include="UndoHistory.cs" />
     <Compile Include="Util.cs" />
+    <Compile Include="Util.String.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/BizHawk.Emulation/Buffer.cs b/BizHawk.Common/Buffer.cs
similarity index 95%
rename from BizHawk.Emulation/Buffer.cs
rename to BizHawk.Common/Buffer.cs
index ef5159cf91..2387f36c49 100644
--- a/BizHawk.Emulation/Buffer.cs
+++ b/BizHawk.Common/Buffer.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Runtime.InteropServices;
 
-namespace BizHawk
+namespace BizHawk.Common
 {
 	/// <summary>
 	/// Implements a data simple data buffer with proper life cycle and no bounds checking
diff --git a/BizHawk.Common/Util.String.cs b/BizHawk.Common/Util.String.cs
new file mode 100644
index 0000000000..7d5f46ccae
--- /dev/null
+++ b/BizHawk.Common/Util.String.cs
@@ -0,0 +1,8 @@
+namespace BizHawk.Common
+{
+	//TODO: delete me
+	public unsafe static partial class Util
+	{
+
+	}
+}
\ No newline at end of file
diff --git a/BizHawk.Common/Util.cs b/BizHawk.Common/Util.cs
index 158e917b33..b61766c58c 100644
--- a/BizHawk.Common/Util.cs
+++ b/BizHawk.Common/Util.cs
@@ -1,11 +1,919 @@
-public unsafe static class Util
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Diagnostics;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace BizHawk.Common
 {
-	static readonly char[] HexConvArr = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-	static System.Runtime.InteropServices.GCHandle HexConvHandle;
-	public static char* HexConvPtr;
-	static unsafe Util()
+	public static class Colors
 	{
-		HexConvHandle = System.Runtime.InteropServices.GCHandle.Alloc(HexConvArr, System.Runtime.InteropServices.GCHandleType.Pinned);
-		HexConvPtr = (char*)HexConvHandle.AddrOfPinnedObject().ToPointer();
+		public static int ARGB(byte red, byte green, byte blue)
+		{
+			return (int)((uint)((red << 0x10) | (green << 8) | blue | (0xFF << 0x18)));
+		}
+
+		public static int ARGB(byte red, byte green, byte blue, byte alpha)
+		{
+			return (int)((uint)((red << 0x10) | (green << 8) | blue | (alpha << 0x18)));
+		}
+
+		public static int Luminosity(byte lum)
+		{
+			return (int)((uint)((lum << 0x10) | (lum << 8) | lum | (0xFF << 0x18)));
+		}
 	}
-}
\ No newline at end of file
+
+	public unsafe static partial class Util
+	{
+		static readonly char[] HexConvArr = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+		static System.Runtime.InteropServices.GCHandle HexConvHandle;
+		public static char* HexConvPtr;
+		static unsafe Util()
+		{
+			HexConvHandle = System.Runtime.InteropServices.GCHandle.Alloc(HexConvArr, System.Runtime.InteropServices.GCHandleType.Pinned);
+			HexConvPtr = (char*)HexConvHandle.AddrOfPinnedObject().ToPointer();
+		}
+
+		public static string Hash_MD5(byte[] data, int offset, int len)
+		{
+			using (var md5 = System.Security.Cryptography.MD5.Create())
+			{
+				md5.TransformFinalBlock(data, offset, len);
+				return Util.BytesToHexString(md5.Hash);
+			}
+		}
+
+		public static string Hash_SHA1(byte[] data, int offset, int len)
+		{
+			using (var sha1 = System.Security.Cryptography.SHA1.Create())
+			{
+				sha1.TransformFinalBlock(data, offset, len);
+				return Util.BytesToHexString(sha1.Hash);
+			}
+		}
+
+		public static bool IsPowerOfTwo(int x)
+		{
+			if (x == 0) return true;
+			if (x == 1) return true;
+			return (x & (x - 1)) == 0;
+		}
+
+		public static int SaveRamBytesUsed(byte[] SaveRAM)
+		{
+			for (int j = SaveRAM.Length - 1; j >= 0; j--)
+				if (SaveRAM[j] != 0)
+					return j + 1;
+			return 0;
+		}
+
+		// Read bytes from a BinaryReader and translate them into the UTF-8 string they represent.
+		public static string ReadStringFixedAscii(this BinaryReader r, int bytes)
+		{
+			byte[] read = new byte[bytes];
+			for (int b = 0; b < bytes; b++)
+				read[b] = r.ReadByte();
+			return System.Text.Encoding.UTF8.GetString(read);
+		}
+
+		public static string ReadStringAsciiZ(this BinaryReader r)
+		{
+			StringBuilder sb = new StringBuilder();
+			for(;;)
+			{
+				int b = r.ReadByte();
+				if(b <= 0) break;
+				sb.Append((char)b);
+			}
+			return sb.ToString();
+		}
+
+		/// <summary>
+		/// conerts bytes to an uppercase string of hex numbers in upper case without any spacing or anything
+		/// //could be extension method
+		/// </summary>
+		public static string BytesToHexString(byte[] bytes)
+		{
+			StringBuilder sb = new StringBuilder();
+			foreach (byte b in bytes)
+				sb.AppendFormat("{0:X2}", b);
+			return sb.ToString();
+		}
+
+		//could be extension method
+		public static byte[] HexStringToBytes(string str)
+		{
+			MemoryStream ms = new MemoryStream();
+			if (str.Length % 2 != 0) throw new ArgumentException();
+			int len = str.Length / 2;
+			for (int i = 0; i < len; i++)
+			{
+				int d = 0;
+				for (int j = 0; j < 2; j++)
+				{
+					char c = char.ToLower(str[i * 2 + j]);
+					if (c >= '0' && c <= '9')
+						d += (c - '0');
+					else if (c >= 'a' && c <= 'f')
+						d += (c - 'a') + 10;
+					else throw new ArgumentException();
+					if (j == 0) d <<= 4;
+				}
+				ms.WriteByte((byte)d);
+			}
+			return ms.ToArray();
+		}
+
+		//could be extension method
+		public static void WriteByteBuffer(BinaryWriter bw, byte[] data)
+		{
+			if (data == null) bw.Write(0);
+			else
+			{
+				bw.Write(data.Length);
+				bw.Write(data);
+			}
+		}
+
+		public static short[] ByteBufferToShortBuffer(byte[] buf)
+		{
+			int num = buf.Length / 2;
+			short[] ret = new short[num];
+			for (int i = 0; i < num; i++)
+			{
+				ret[i] = (short)(buf[i * 2] | (buf[i * 2 + 1] << 8));
+			}
+			return ret;
+		}
+
+		public static byte[] ShortBufferToByteBuffer(short[] buf)
+		{
+			int num = buf.Length;
+			byte[] ret = new byte[num * 2];
+			for (int i = 0; i < num; i++)
+			{
+				ret[i * 2 + 0] = (byte)(buf[i] & 0xFF);
+				ret[i * 2 + 1] = (byte)((buf[i] >> 8) & 0xFF);
+			}
+			return ret;
+		}
+
+		public static uint[] ByteBufferToUintBuffer(byte[] buf)
+		{
+			int num = buf.Length / 4;
+			uint[] ret = new uint[num];
+			for (int i = 0; i < num; i++)
+			{
+				ret[i] = (uint)(buf[i * 4] | (buf[i * 4 + 1] << 8) | (buf[i * 4 + 2] << 16) | (buf[i * 4 + 3] << 24));
+			}
+			return ret;
+		}
+
+		public static byte[] UintBufferToByteBuffer(uint[] buf)
+		{
+			int num = buf.Length;
+			byte[] ret = new byte[num * 4];
+			for (int i = 0; i < num; i++)
+			{
+				ret[i * 4 + 0] = (byte)(buf[i] & 0xFF);
+				ret[i * 4 + 1] = (byte)((buf[i] >> 8) & 0xFF);
+				ret[i * 4 + 2] = (byte)((buf[i] >> 16) & 0xFF);
+				ret[i * 4 + 3] = (byte)((buf[i] >> 24) & 0xFF);
+			}
+			return ret;
+		}
+
+		public static int[] ByteBufferToIntBuffer(byte[] buf)
+		{
+			int num = buf.Length / 4;
+			int[] ret = new int[num];
+			for (int i = 0; i < num; i++)
+			{
+				ret[i] = buf[(i * 4) + 3];
+				ret[i] <<= 8;
+				ret[i] |= buf[(i * 4) + 2];
+				ret[i] <<= 8;
+				ret[i] |= buf[(i * 4) + 1];
+				ret[i] <<= 8;
+				ret[i] |= buf[(i * 4)];
+			}
+			return ret;
+		}
+
+		public static byte[] IntBufferToByteBuffer(int[] buf)
+		{
+			int num = buf.Length;
+			byte[] ret = new byte[num * 4];
+			for (int i = 0; i < num; i++)
+			{
+				ret[i * 4 + 0] = (byte)(buf[i] & 0xFF);
+				ret[i * 4 + 1] = (byte)((buf[i] >> 8) & 0xFF);
+				ret[i * 4 + 2] = (byte)((buf[i] >> 16) & 0xFF);
+				ret[i * 4 + 3] = (byte)((buf[i] >> 24) & 0xFF);
+			}
+			return ret;
+		}
+
+		public static byte[] ReadByteBuffer(BinaryReader br, bool return_null)
+		{
+			int len = br.ReadInt32();
+			if (len == 0 && return_null) return null;
+			byte[] ret = new byte[len];
+			int ofs = 0;
+			while (len > 0)
+			{
+				int done = br.Read(ret, ofs, len);
+				ofs += done;
+				len -= done;
+			}
+			return ret;
+		}
+
+		public static unsafe int memcmp(void* a, string b, int len)
+		{
+			fixed (byte* bp = System.Text.Encoding.ASCII.GetBytes(b))
+				return memcmp(a, bp, len);
+		}
+
+		public static unsafe int memcmp(void* a, void* b, int len)
+		{
+			byte* ba = (byte*)a;
+			byte* bb = (byte*)b;
+			for (int i = 0; i < len; i++)
+			{
+				byte _a = ba[i];
+				byte _b = bb[i];
+				int c = _a - _b;
+				if (c != 0) return c;
+			}
+			return 0;
+		}
+
+		public static unsafe void memset(void* ptr, int val, int len)
+		{
+			byte* bptr = (byte*)ptr;
+			for (int i = 0; i < len; i++)
+				bptr[i] = (byte)val;
+		}
+
+		public static unsafe void memset32(void* ptr, int val, int len)
+		{
+			System.Diagnostics.Debug.Assert(len % 4 == 0);
+			int dwords = len / 4;
+			int* dwptr = (int*)ptr;
+			for (int i = 0; i < dwords; i++)
+				dwptr[i] = val;
+		}
+
+		public static byte[] ReadAllBytes(Stream stream)
+		{
+			const int BUFF_SIZE = 4096;
+			byte[] buffer = new byte[BUFF_SIZE];
+
+			int bytesRead = 0;
+			var inStream = new BufferedStream(stream);
+			var outStream = new MemoryStream();
+
+			while ((bytesRead = inStream.Read(buffer, 0, BUFF_SIZE)) > 0)
+			{
+				outStream.Write(buffer, 0, bytesRead);
+			}
+
+			return outStream.ToArray();
+		}
+
+        public static byte BinToBCD(this byte v)
+        {
+            return (byte) (((v / 10) * 16) + (v % 10));
+        }
+
+        public static byte BCDtoBin(this byte v)
+        {
+            return (byte) (((v / 16) * 10) + (v % 16));
+        }
+
+		public static string FormatFileSize(long filesize)
+		{
+			Decimal size = (Decimal)filesize;
+
+			Decimal OneKiloByte = 1024M;
+			Decimal OneMegaByte = OneKiloByte * 1024M;
+			Decimal OneGigaByte = OneMegaByte * 1024M;
+
+			string suffix;
+			if (size > 1024 * 1024 * 1024)
+			{
+				size /= 1024 * 1024 * 1024;
+				suffix = "GB";
+			}
+			else if (size > 1024 * 1024)
+			{
+				size /= 1024 * 1024;
+				suffix = "MB";
+			}
+			else if (size > 1024)
+			{
+				size /= 1024;
+				suffix = "KB";
+			}
+			else
+			{
+				suffix = " B";
+			}
+
+			string precision = "2";
+			return String.Format("{0:N" + precision + "}{1}", size, suffix);
+		}
+	}
+
+	public unsafe class Serializer
+	{
+		BinaryReader br;
+		BinaryWriter bw;
+		TextReader tr;
+		TextWriter tw;
+		public BinaryReader BinaryReader { get { return br; } }
+		public BinaryWriter BinaryWriter { get { return bw; } }
+		public TextReader TextReader { get { return tr; } }
+		public TextWriter TextWriter { get { return tw; } }
+		public Serializer() { }
+		public Serializer(BinaryWriter _bw) { StartWrite(_bw); }
+		public Serializer(BinaryReader _br) { StartRead(_br); }
+		public Serializer(TextWriter _tw) { StartWrite(_tw); }
+		public Serializer(TextReader _tr) { StartRead(_tr); }
+		public static Serializer CreateBinaryWriter(BinaryWriter _bw) { return new Serializer(_bw); }
+		public static Serializer CreateBinaryReader(BinaryReader _br) { return new Serializer(_br); }
+		public static Serializer CreateTextWriter(TextWriter _tw) { return new Serializer(_tw); }
+		public static Serializer CreateTextReader(TextReader _tr) { return new Serializer(_tr); }
+		public void StartWrite(BinaryWriter _bw) { this.bw = _bw; isReader = false; }
+		public void StartRead(BinaryReader _br) { this.br = _br; isReader = true; }
+		public void StartWrite(TextWriter _tw) { this.tw = _tw; isReader = false; isText = true; }
+		public void StartRead(TextReader _tr) {
+			this.tr = _tr;
+			isReader = true; 
+			isText = true;
+			BeginTextBlock();
+		}
+
+		public bool IsReader { get { return isReader; } }
+		public bool IsWriter { get { return !IsReader; } }
+		public bool IsText { get { return isText; } }
+		bool isText;
+		bool isReader;
+
+		Stack<string> sections = new Stack<string>();
+
+		class Section : Dictionary<string, Section>
+		{
+			public string Name;
+			public Dictionary<string, string> Items = new Dictionary<string, string>();
+		}
+
+		Section ReaderSection, CurrSection;
+		Stack<Section> SectionStack = new Stack<Section>();
+
+		void BeginTextBlock()
+		{
+			if (!IsText) return;
+			if (IsWriter) return;
+
+			ReaderSection = new Section();
+			ReaderSection.Name = "";
+			Stack<Section> ss = new Stack<Section>();
+			ss.Push(ReaderSection);
+			Section curs = ReaderSection;
+
+			var rxEnd = new System.Text.RegularExpressions.Regex(@"\[/(.*?)\]",System.Text.RegularExpressions.RegexOptions.Compiled);
+			var rxBegin = new System.Text.RegularExpressions.Regex(@"\[(.*?)\]",System.Text.RegularExpressions.RegexOptions.Compiled);
+
+			//read the entire file into a data structure for flexi-parsing
+			string str;
+			while ((str = tr.ReadLine()) != null)
+			{
+				var end = rxEnd.Match(str);
+				var begin = rxBegin.Match(str);
+				if (end.Success)
+				{
+					string name = end.Groups[1].Value;
+					if (name != curs.Name) throw new InvalidOperationException("Mis-formed savestate blob");
+					curs = ss.Pop();
+					// consume no data past the end of the last proper section
+					if (curs == ReaderSection)
+					{
+						CurrSection = curs;
+						return;
+					}
+				}
+				else if (begin.Success)
+				{
+					string name = begin.Groups[1].Value;
+					ss.Push(curs);
+					var news = new Section();
+					news.Name = name;
+					if (!curs.ContainsKey(name))
+						curs[name] = news;
+					else
+						throw new Exception(string.Format("Duplicate key \"{0}\" in serializer savestate!", name));
+					curs = news;
+				}
+				else
+				{
+					//add to current section
+					if (str.Trim().Length == 0) continue;
+					var parts = str.Split(' ');
+					var key = parts[0];
+					//UGLY: adds whole string instead of splitting the key. later, split the key, and have the individual Sync methods give up that responsibility
+					if (!curs.Items.ContainsKey(key))
+						curs.Items[key] = parts[1];
+					else
+						throw new Exception(string.Format("Duplicate key \"{0}\" in serializer savestate!", key));
+				}
+			}
+
+			CurrSection = ReaderSection;
+		}
+
+		public void BeginSection(string name)
+		{
+			sections.Push(name);
+			if (IsText) 
+				if (IsWriter) { tw.WriteLine("[{0}]", name); }
+				else 
+				{
+					SectionStack.Push(CurrSection);
+					CurrSection = CurrSection[name];
+				}
+		}
+
+		public void EndSection()
+		{
+			string name = sections.Pop();
+			if (IsText)
+				if (IsWriter) tw.WriteLine("[/{0}]", name);
+				else
+				{
+					CurrSection = SectionStack.Pop();
+				}
+		}
+
+		string Item(string key)
+		{
+			return CurrSection.Items[key];
+		}
+
+		bool Present(string key)
+		{
+			return CurrSection.Items.ContainsKey(key);
+		}
+
+		public void SyncEnum<T>(string name, ref T val) where T : struct
+		{
+			if (typeof(T).BaseType != typeof(System.Enum))
+				throw new InvalidOperationException();
+			if (isText) SyncEnumText<T>(name, ref val);
+			else if (IsReader) val = (T)Enum.ToObject(typeof(T), br.ReadInt32());
+			else bw.Write(Convert.ToInt32(val));
+		}
+
+		public void SyncEnumText<T>(string name, ref T val) where T : struct
+		{
+			if (IsReader) { if (Present(name)) val = (T)Enum.Parse(typeof(T), Item(name)); }
+			else tw.WriteLine("{0} {1}", name, val.ToString());
+		}
+
+		void SyncBuffer(string name, int elemsize, int len, void* ptr)
+		{
+			if (IsReader)
+			{
+				byte[] temp = null;
+				Sync(name, ref temp, false);
+				int todo = Math.Min(temp.Length, len * elemsize);
+				System.Runtime.InteropServices.Marshal.Copy(temp, 0, new IntPtr(ptr), todo);
+			}
+			else
+			{
+				int todo = len * elemsize;
+				byte[] temp = new byte[todo];
+				System.Runtime.InteropServices.Marshal.Copy(new IntPtr(ptr), temp, 0, todo);
+				Sync(name, ref temp, false);
+			}
+		}
+
+		public void Sync(string name, ref ByteBuffer byteBuf)
+		{
+			SyncBuffer(name, 1, byteBuf.len, byteBuf.ptr);
+		}
+
+		public void Sync(string name, ref IntBuffer byteBuf)
+		{
+			SyncBuffer(name, 4, byteBuf.len, byteBuf.ptr);
+		}
+
+		public void Sync(string name, ref byte[] val, bool use_null)
+		{
+			if (IsText) SyncText(name, ref val, use_null);
+			else if (IsReader) val = Util.ReadByteBuffer(br, use_null);
+			else Util.WriteByteBuffer(bw, val);
+		}
+		public void SyncText(string name, ref byte[] val, bool use_null)
+		{
+			if (IsReader)
+			{
+				if(Present(name)) val = Util.HexStringToBytes(Item(name));
+				if (val != null && val.Length == 0 && use_null) val = null;
+			}
+			else
+			{
+				byte[] temp = val;
+				if (temp == null) temp = new byte[0];
+				tw.WriteLine("{0} {1}", name, Util.BytesToHexString(temp));
+			}
+		}
+
+		public void Sync(string name, ref short[] val, bool use_null)
+		{
+			if (IsText) SyncText(name, ref val, use_null);
+			else if (IsReader)
+			{
+				val = Util.ByteBufferToShortBuffer(Util.ReadByteBuffer(br, false));
+				if (val == null && !use_null) val = new short[0];
+			}
+			else Util.WriteByteBuffer(bw, Util.ShortBufferToByteBuffer(val));
+		}
+		public void SyncText(string name, ref short[] val, bool use_null)
+		{
+			if (IsReader)
+			{
+				if (Present(name))
+				{
+					byte[] bytes = Util.HexStringToBytes(Item(name));
+					val = Util.ByteBufferToShortBuffer(bytes);
+				}
+				if (val != null && val.Length == 0 && use_null) val = null;
+			}
+			else
+			{
+				short[] temp = val;
+				if (temp == null) temp = new short[0];
+				tw.WriteLine("{0} {1}", name, Util.BytesToHexString(Util.ShortBufferToByteBuffer(temp)));
+			}
+		}
+
+		public void Sync(string name, ref int[] val, bool use_null)
+		{
+			if (IsText) SyncText(name, ref val, use_null);
+			else if (IsReader)
+			{
+				val = Util.ByteBufferToIntBuffer(Util.ReadByteBuffer(br, false));
+				if (val == null && !use_null) val = new int[0];
+			}
+			else Util.WriteByteBuffer(bw, Util.IntBufferToByteBuffer(val));
+		}
+		public void SyncText(string name, ref int[] val, bool use_null)
+		{
+			if (IsReader)
+			{
+				if (Present(name))
+				{
+					byte[] bytes = Util.HexStringToBytes(Item(name));
+					val = Util.ByteBufferToIntBuffer(bytes);
+				}
+				if (val != null && val.Length == 0 && use_null) val = null;
+			}
+			else
+			{
+				int[] temp = val;
+				if (temp == null) temp = new int[0];
+				tw.WriteLine("{0} {1}", name, Util.BytesToHexString(Util.IntBufferToByteBuffer(temp)));
+			}
+		}
+
+		public void Sync(string name, ref uint[] val, bool use_null)
+		{
+			if (IsText) SyncText(name, ref val, use_null);
+			else if (IsReader)
+			{
+				val = Util.ByteBufferToUintBuffer(Util.ReadByteBuffer(br, false));
+				if (val == null && !use_null) val = new uint[0];
+			}
+			else Util.WriteByteBuffer(bw, Util.UintBufferToByteBuffer(val));
+		}
+		public void SyncText(string name, ref uint[] val, bool use_null)
+		{
+			if (IsReader)
+			{
+				if(Present(name))
+				{
+					byte[] bytes = Util.HexStringToBytes(Item(name));
+					val = Util.ByteBufferToUintBuffer(bytes);
+				}
+				if (val != null && val.Length == 0 && use_null) val = null;
+			}
+			else
+			{
+				uint[] temp = val;
+				if (temp == null) temp = new uint[0];
+				tw.WriteLine("{0} {1}", name, Util.BytesToHexString(Util.UintBufferToByteBuffer(temp)));
+			}
+		}
+
+		public void Sync(string name, ref Bit val)
+		{
+			if (IsText) SyncText(name, ref val);
+			else if (IsReader) Read(ref val);
+			else Write(ref val);
+		}
+		public void SyncText(string name, ref Bit val)
+		{
+			if (IsReader) ReadText(name, ref val);
+			else WriteText(name, ref val);
+		}
+		public void Sync(string name, ref byte val)
+		{
+			if (IsText) SyncText(name, ref val);
+			else if (IsReader) Read(ref val);
+			else Write(ref val);
+		}
+		void SyncText(string name, ref byte val)
+		{
+			if (IsReader) ReadText(name, ref val);
+			else WriteText(name, ref val);
+		}
+		public void Sync(string name, ref ushort val)
+		{
+			if (IsText) SyncText(name, ref val);
+			else if (IsReader) Read(ref val);
+			else Write(ref val);
+		}
+		void SyncText(string name, ref ushort val)
+		{
+			if (IsReader) ReadText(name, ref val);
+			else WriteText(name, ref val);
+		}
+		public void Sync(string name, ref uint val)
+		{
+			if (IsText) SyncText(name, ref val);
+			else if (IsReader) Read(ref val);
+			else Write(ref val);
+		}
+		void SyncText(string name, ref uint val)
+		{
+			if (IsReader) ReadText(name, ref val);
+			else WriteText(name, ref val);
+		}
+		public void Sync(string name, ref sbyte val)
+		{
+			if (IsText) SyncText(name, ref val);
+			else if (IsReader) Read(ref val);
+			else Write(ref val);
+		}
+		void SyncText(string name, ref sbyte val)
+		{
+			if (IsReader) ReadText(name, ref val);
+			else WriteText(name, ref val);
+		}
+		public void Sync(string name, ref short val)
+		{
+			if (IsText) SyncText(name, ref val);
+			else if (IsReader) Read(ref val);
+			else Write(ref val);
+		}
+		void SyncText(string name, ref short val)
+		{
+			if (IsReader) ReadText(name, ref val);
+			else WriteText(name, ref val);
+		}
+		public void Sync(string name, ref int val)
+		{
+			if (IsText) SyncText(name, ref val);
+			else if (IsReader) Read(ref val);
+			else Write(ref val);
+		}
+		void SyncText(string name, ref int val)
+		{
+			if (IsReader) ReadText(name, ref val);
+			else WriteText(name, ref val);
+		}
+		public void Sync(string name, ref bool val)
+		{
+			if (IsText) SyncText(name, ref val);
+			else if (IsReader) Read(ref val);
+			else Write(ref val);
+		}
+		void SyncText(string name, ref bool val)
+		{
+			if (IsReader) ReadText(name, ref val);
+			else WriteText(name, ref val);
+		}
+		public void SyncFixedString(string name, ref string val, int length)
+		{
+			//TODO - this could be made more efficient perhaps just by writing values right out of the string..
+
+			if (IsReader)
+			{
+				char[] buf = new char[length];
+				if (isText)
+				{
+					tr.Read(buf, 0, length);
+				}
+				else
+				{
+					br.Read(buf, 0, length);
+				}
+				int len = 0;
+				for (; len < length; len++)
+				{
+					if (buf[len] == 0) break;
+				}
+				val = new string(buf, 0, len);
+			}
+			else
+			{
+				if (name.Length > length) throw new InvalidOperationException("SyncFixedString too long");
+				char[] buf = val.ToCharArray();
+				char[] remainder = new char[length - buf.Length];
+				if (IsText)
+				{
+					tw.Write(buf);
+					tw.Write(remainder);
+				}
+				else
+				{
+					bw.Write(buf);
+					bw.Write(remainder);
+				}
+			}
+		}
+
+		void Read(ref Bit val) { val = br.ReadBit(); }
+		void Write(ref Bit val) { bw.WriteBit(val); }
+		void ReadText(string name, ref Bit val) { if(Present(name)) val = (Bit)int.Parse(Item(name)); }
+		void WriteText(string name, ref Bit val) { tw.WriteLine("{0} {1}", name, (int)val); }
+
+		void Read(ref byte val) { val = br.ReadByte(); }
+		void Write(ref byte val) { bw.Write(val); }
+		void ReadText(string name, ref byte val) { if (Present(name)) val = byte.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
+		void WriteText(string name, ref byte val) { tw.WriteLine("{0} 0x{1:X2}", name, val); }
+
+		void Read(ref ushort val) { val = br.ReadUInt16(); }
+		void Write(ref ushort val) { bw.Write(val); }
+		void ReadText(string name, ref ushort val) { if (Present(name)) val = ushort.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
+		void WriteText(string name, ref ushort val) { tw.WriteLine("{0} 0x{1:X4}", name, val); }
+
+		void Read(ref uint val) { val = br.ReadUInt32(); }
+		void Write(ref uint val) { bw.Write(val); }
+		void ReadText(string name, ref uint val) { if (Present(name)) val = uint.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
+		void WriteText(string name, ref uint val) { tw.WriteLine("{0} 0x{1:X8}", name, val); }
+
+		void Read(ref sbyte val) { val = br.ReadSByte(); }
+		void Write(ref sbyte val) { bw.Write(val); }
+		void ReadText(string name, ref sbyte val) { if (Present(name)) val = sbyte.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
+		void WriteText(string name, ref sbyte val) { tw.WriteLine("{0} 0x{1:X2}", name, val); }
+
+		void Read(ref short val) { val = br.ReadInt16(); }
+		void Write(ref short val) { bw.Write(val); }
+		void ReadText(string name, ref short val) { if (Present(name)) val = short.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
+		void WriteText(string name, ref short val) { tw.WriteLine("{0} 0x{1:X4}", name, val); }
+
+		void Read(ref int val) { val = br.ReadInt32(); }
+		void Write(ref int val) { bw.Write(val); }
+		void ReadText(string name, ref int val) { if (Present(name)) val = int.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
+		void WriteText(string name, ref int val) { tw.WriteLine("{0} 0x{1:X8}", name, val); }
+
+		void Read(ref bool val) { val = br.ReadBoolean(); }
+		void Write(ref bool val) { bw.Write(val); }
+		void ReadText(string name, ref bool val) { if (Present(name)) val = bool.Parse(Item(name)); }
+		void WriteText(string name, ref bool val) { tw.WriteLine("{0} {1}", name, val); }
+	}
+
+
+	public static class BITREV
+	{
+		public static byte[] byte_8;
+		static BITREV()
+		{
+			make_byte_8();
+		}
+		static void make_byte_8()
+		{
+			int bits = 8;
+			int n = 1 << 8;
+			byte_8 = new byte[n];
+
+			int m = 1;
+			int a = n >> 1;
+			int j = 2;
+
+			byte_8[0] = 0;
+			byte_8[1] = (byte)a;
+
+			while ((--bits) != 0)
+			{
+				m <<= 1;
+				a >>= 1;
+				for (int i = 0; i < m; i++)
+					byte_8[j++] = (byte)(byte_8[i] + a);
+			}
+		}
+
+		public static uint reverse_32(uint v)
+		{
+			return (uint)((byte_8[v & 0xff] << 24) |
+					(byte_8[(v >> 8) & 0xff] << 16) |
+					(byte_8[(v >> 16) & 0xff] << 8) |
+					(byte_8[(v >> 24) & 0xff]));
+		}
+	}
+
+	/// <summary>
+	/// a Dictionary-of-lists with key K and values List&lt;V&gt;
+	/// </summary>
+	[Serializable]
+	public class Bag<K, V> : BagBase<K, V, Dictionary<K, List<V>>, List<V>> { }
+
+	/// <summary>
+	/// a Dictionary-of-lists with key K and values List&lt;V&gt;
+	/// </summary>
+	[Serializable]
+	public class SortedBag<K, V> : BagBase<K, V, SortedDictionary<K, List<V>>, List<V>> { }
+
+	/// <summary>
+	/// A dictionary that creates new values on the fly as necessary so that any key you need will be defined. 
+	/// </summary>
+	/// <typeparam name="K">dictionary keys</typeparam>
+	/// <typeparam name="V">dictionary values</typeparam>
+	public class WorkingDictionary<K, V> : Dictionary<K, V> where V : new()
+	{
+		public new V this[K key]
+		{
+			get
+			{
+				V temp;
+				if (!TryGetValue(key, out temp))
+					temp = this[key] = new V();
+				return temp;
+			}
+			set { base[key] = value; }
+		}
+	}
+
+	/// <summary>
+	/// base class for Bag and SortedBag
+	/// </summary>
+	/// <typeparam name="K">dictionary keys</typeparam>
+	/// <typeparam name="V">list values</typeparam>
+	/// <typeparam name="D">dictionary type</typeparam>
+	/// <typeparam name="L">list type</typeparam>
+	[Serializable]
+	public class BagBase<K, V, D, L> : IEnumerable<V>
+		where D : IDictionary<K, L>, new()
+		where L : IList<V>, IEnumerable<V>, new()
+	{
+		D dictionary = new D();
+		public void Add(K key, V val)
+		{
+			this[key].Add(val);
+		}
+
+		public bool ContainsKey(K key) { return dictionary.ContainsKey(key); }
+
+		IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }
+		public IEnumerator<V> GetEnumerator()
+		{
+			foreach (L lv in dictionary.Values)
+				foreach (V v in lv)
+					yield return v;
+		}
+
+		public IEnumerable KeyValuePairEnumerator { get { return dictionary; } }
+
+		/// <summary>
+		/// the list of keys contained herein
+		/// </summary>
+		public IList<K> Keys { get { return new List<K>(dictionary.Keys); } }
+
+		public L this[K key]
+		{
+			get
+			{
+				L slot;
+				if (!dictionary.TryGetValue(key, out slot))
+					dictionary[key] = slot = new L();
+				return slot;
+			}
+			set
+			{
+				dictionary[key] = value;
+			}
+		}
+	}
+
+    public class NotTestedException : Exception
+    {
+    }
+}
diff --git a/BizHawk.Emulation.DiscSystem/BizHawk.Emulation.DiscSystem.csproj b/BizHawk.Emulation.DiscSystem/BizHawk.Emulation.DiscSystem.csproj
index d9c0b900bd..3fcd778295 100644
--- a/BizHawk.Emulation.DiscSystem/BizHawk.Emulation.DiscSystem.csproj
+++ b/BizHawk.Emulation.DiscSystem/BizHawk.Emulation.DiscSystem.csproj
@@ -45,7 +45,6 @@
     <Compile Include="Blobs\Blob_ECM.cs" />
     <Compile Include="Blobs\Blob_WaveFile.cs" />
     <Compile Include="Blobs\RiffMaster.cs" />
-    <Compile Include="Buffer.cs" />
     <Compile Include="CCD_format.cs" />
     <Compile Include="cdfs\EndianBitConverter.cs" />
     <Compile Include="cdfs\ISODirectoryNode.cs" />
diff --git a/BizHawk.Emulation.DiscSystem/Buffer.cs b/BizHawk.Emulation.DiscSystem/Buffer.cs
deleted file mode 100644
index e2cd4adec6..0000000000
--- a/BizHawk.Emulation.DiscSystem/Buffer.cs
+++ /dev/null
@@ -1,118 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-//TODO: quick fix, this is the same file as BizHawk.Emulation, move it to BizHawk.Common
-namespace BizHawk.Emulation.DiscSystem
-{
-	/// <summary>
-	/// Implements a data simple data buffer with proper life cycle and no bounds checking
-	/// </summary>
-	public unsafe class CBuffer<T> : IDisposable
-	{
-		public GCHandle hnd;
-		public T[] arr;
-		public void* ptr;
-		public byte* byteptr;
-		public int len;
-		public int itemsize;
-
-		public static CBuffer<T> malloc(int amt, int itemsize)
-		{
-			return new CBuffer<T>(amt, itemsize);
-		}
-
-		public void Write08(uint addr, byte val) { byteptr[addr] = val; }
-		public void Write16(uint addr, ushort val) { *(ushort*)(byteptr + addr) = val; }
-		public void Write32(uint addr, uint val) { *(uint*)(byteptr + addr) = val; }
-		public void Write64(uint addr, ulong val) { *(ulong*)(byteptr + addr) = val; }
-		public byte Read08(uint addr) { return byteptr[addr]; }
-		public ushort Read16(uint addr) { return *(ushort*)(byteptr + addr); }
-		public uint Read32(uint addr) { return *(uint*)(byteptr + addr); }
-		public ulong Read64(uint addr) { return *(ulong*)(byteptr + addr); }
-		public void Write08(int addr, byte val) { byteptr[addr] = val; }
-		public void Write16(int addr, ushort val) { *(ushort*)(byteptr + addr) = val; }
-		public void Write32(int addr, uint val) { *(uint*)(byteptr + addr) = val; }
-		public void Write64(int addr, ulong val) { *(ulong*)(byteptr + addr) = val; }
-		public byte Read08(int addr) { return byteptr[addr]; }
-		public ushort Read16(int addr) { return *(ushort*)(byteptr + addr); }
-		public uint Read32(int addr) { return *(uint*)(byteptr + addr); }
-		public ulong Read64(int addr) { return *(ulong*)(byteptr + addr); }
-
-		public CBuffer(T[] arr, int itemsize)
-		{
-			this.itemsize = itemsize;
-			len = arr.Length;
-			this.arr = arr;
-			hnd = GCHandle.Alloc(arr, GCHandleType.Pinned);
-			ptr = hnd.AddrOfPinnedObject().ToPointer();
-			byteptr = (byte*)ptr;
-		}
-		public CBuffer(int amt, int itemsize)
-		{
-			this.itemsize = itemsize;
-			len = amt;
-			arr = new T[amt];
-			hnd = GCHandle.Alloc(arr, GCHandleType.Pinned);
-			ptr = hnd.AddrOfPinnedObject().ToPointer();
-			byteptr = (byte*)ptr;
-			Util.memset(byteptr, 0, len * itemsize);
-		}
-
-		public void Dispose()
-		{
-			if (arr != null)
-				hnd.Free();
-			arr = null;
-		}
-
-		~CBuffer() { Dispose(); }
-	}
-
-	public class ByteBuffer : CBuffer<byte>
-	{
-		public ByteBuffer(int amt) : base(amt,1) { }
-		public ByteBuffer(byte[] arr) : base(arr,1) { }
-		public byte this[int index]
-		{
-			#if DEBUG
-				get { return arr[index]; }
-				set { arr[index] = value; }
-			#else
-				set { Write08(index, value); } 
-				get { return Read08(index);}
-			#endif
-		}
-	}
-
-	public class IntBuffer : CBuffer<int>
-	{
-		public IntBuffer(int amt) : base(amt, 4) { }
-		public IntBuffer(int[] arr) : base(arr,4) { }
-		public int this[int index]
-		{
-			#if DEBUG
-				get { return arr[index]; }
-				set { arr[index] = value; }
-			#else
-				set { Write32(index<<2, (uint) value); }
-				get { return (int)Read32(index<<2);}
-			#endif
-		}
-	}
-
-	public class ShortBuffer : CBuffer<short>
-	{
-		public ShortBuffer(int amt) : base(amt, 2) { }
-		public ShortBuffer(short[] arr) : base(arr, 2) { }
-		public short this[int index]
-		{
-#if DEBUG
-				get { return arr[index]; }
-				set { arr[index] = value; }
-#else
-			set { Write32(index << 1, (uint)value); }
-			get { return (short)Read16(index << 1); }
-#endif
-		}
-	}
-}
\ No newline at end of file
diff --git a/BizHawk.Emulation.DiscSystem/Disc.API.cs b/BizHawk.Emulation.DiscSystem/Disc.API.cs
index 774b5fcda1..a68275531e 100644
--- a/BizHawk.Emulation.DiscSystem/Disc.API.cs
+++ b/BizHawk.Emulation.DiscSystem/Disc.API.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 
+using BizHawk.Common;
+
 //main apis for emulator core routine use
 
 namespace BizHawk.Emulation.DiscSystem
diff --git a/BizHawk.Emulation.DiscSystem/ECM.cs b/BizHawk.Emulation.DiscSystem/ECM.cs
index 0274a6742c..6cc02968ca 100644
--- a/BizHawk.Emulation.DiscSystem/ECM.cs
+++ b/BizHawk.Emulation.DiscSystem/ECM.cs
@@ -28,6 +28,8 @@
 //Corlett's ECM uses our same fundamental approach as well.
 //I can't figure out what winUAE is doing.
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.DiscSystem
 {
 	static class ECM
diff --git a/BizHawk.Emulation.DiscSystem/Util.cs b/BizHawk.Emulation.DiscSystem/Util.cs
index 77ba261277..6b554fa099 100644
--- a/BizHawk.Emulation.DiscSystem/Util.cs
+++ b/BizHawk.Emulation.DiscSystem/Util.cs
@@ -9,11 +9,11 @@ using System.IO;
 using System.Text;
 
 using BizHawk.Common;
-
+/*
 namespace BizHawk.Emulation.DiscSystem
 {
 	//TODO: QUICK FIX, this is the same file as BizHawk.Emulation, move to BizHawk.Common and get rid of this
-	public static class Colors
+	internal static class Colors
 	{
 		public static int ARGB(byte red, byte green, byte blue)
 		{
@@ -31,7 +31,7 @@ namespace BizHawk.Emulation.DiscSystem
 		}
 	}
 
-	public unsafe static class Util
+	internal unsafe static class Util
 	{
 		static readonly char[] HexConvArr = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 		static System.Runtime.InteropServices.GCHandle HexConvHandle;
@@ -920,3 +920,4 @@ namespace BizHawk.Emulation.DiscSystem
     {
     }
 }
+*/
\ No newline at end of file
diff --git a/BizHawk.Emulation/BizHawk.Emulation.csproj b/BizHawk.Emulation/BizHawk.Emulation.csproj
index e774e0304c..2998fbf7e2 100644
--- a/BizHawk.Emulation/BizHawk.Emulation.csproj
+++ b/BizHawk.Emulation/BizHawk.Emulation.csproj
@@ -82,7 +82,6 @@
     <Compile Include="..\VersionInfo.cs">
       <Link>VersionInfo.cs</Link>
     </Compile>
-    <Compile Include="Buffer.cs" />
     <Compile Include="Computers\Commodore64\C64.Core.cs" />
     <Compile Include="Computers\Commodore64\C64.cs" />
     <Compile Include="Computers\Commodore64\C64.Motherboard.cs" />
@@ -507,7 +506,6 @@
     <Compile Include="Consoles\Sega\SMS\SMS.cs" />
     <Compile Include="Consoles\Sega\SMS\VDP.cs" />
     <Compile Include="Sound\YM2413.cs" />
-    <Compile Include="Util.cs" />
     <Compile Include="Sound\Utilities\Waves.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502X.cs b/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502X.cs
index 2d8560dc8c..0a0e526ddc 100644
--- a/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502X.cs	
+++ b/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502X.cs	
@@ -1,6 +1,8 @@
 using System;
 using System.IO;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.CPUs.M6502
 {
 	public sealed partial class MOS6502X
diff --git a/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502XDouble.cs b/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502XDouble.cs
index a76daf7078..f4fac02eac 100644
--- a/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502XDouble.cs	
+++ b/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502XDouble.cs	
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.CPUs.M6502
 {
 	/// <summary>
diff --git a/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502XNative.cs b/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502XNative.cs
index 33f974e19d..3489311e98 100644
--- a/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502XNative.cs	
+++ b/BizHawk.Emulation/CPUs/MOS 6502X/MOS6502XNative.cs	
@@ -1,6 +1,8 @@
 using System;
 using System.Runtime.InteropServices;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.CPUs.M6502
 {
 	public static class MOS6502X_DLL
diff --git a/BizHawk.Emulation/Computers/Commodore64/C64.Motherboard.cs b/BizHawk.Emulation/Computers/Commodore64/C64.Motherboard.cs
index 17273a72e9..49efc47762 100644
--- a/BizHawk.Emulation/Computers/Commodore64/C64.Motherboard.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/C64.Motherboard.cs
@@ -1,11 +1,13 @@
 using BizHawk.Emulation.Computers.Commodore64.MOS;
 using System.Reflection;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64
 {
-    /// <summary>
-    /// Contains the onboard chipset and glue.
-    /// </summary>
+	/// <summary>
+	/// Contains the onboard chipset and glue.
+	/// </summary>
 	sealed public partial class Motherboard
 	{
 		// chips
@@ -24,7 +26,7 @@ namespace BizHawk.Emulation.Computers.Commodore64
 		// ports
 		public CartridgePort cartPort;
 		public CassettePort cassPort;
-        public IController controller;
+		public IController controller;
 		public SerialPort serPort;
 		public UserPort userPort;
 
@@ -32,8 +34,8 @@ namespace BizHawk.Emulation.Computers.Commodore64
 		//public int address;
 		public byte bus;
 		public bool inputRead;
-        public bool irq;
-        public bool nmi;
+		public bool irq;
+		public bool nmi;
 
 		public Motherboard(Region initRegion)
 		{
@@ -42,7 +44,7 @@ namespace BizHawk.Emulation.Computers.Commodore64
 			cartPort = new CartridgePort();
 			cassPort = new CassettePort();
 			cia0 = new MOS6526(initRegion);
-            cia1 = new MOS6526(initRegion);
+			cia1 = new MOS6526(initRegion);
 			colorRam = new Chip2114();
 			cpu = new MOS6510();
 			pla = new MOSPLA();
@@ -61,22 +63,22 @@ namespace BizHawk.Emulation.Computers.Commodore64
 
 		public void Execute()
 		{
-            vic.ExecutePhase1();
-            cpu.ExecutePhase1();
-            cia0.ExecutePhase1();
+			vic.ExecutePhase1();
+			cpu.ExecutePhase1();
+			cia0.ExecutePhase1();
 			cia1.ExecutePhase1();
 
-            vic.ExecutePhase2();
-            cpu.ExecutePhase2();
-            cia0.ExecutePhase2();
+			vic.ExecutePhase2();
+			cpu.ExecutePhase2();
+			cia0.ExecutePhase2();
 			cia1.ExecutePhase2();
 			sid.ExecutePhase2();
-        }
+		}
 
-        public void Flush()
-        {
-            sid.Flush();
-        }
+		public void Flush()
+		{
+			sid.Flush();
+		}
 
 		// -----------------------------------------
 
@@ -101,32 +103,32 @@ namespace BizHawk.Emulation.Computers.Commodore64
 
 		public void Init()
 		{
-            cartPort.ReadIRQ = Glue_ReadIRQ;
-            cartPort.ReadNMI = cia1.ReadIRQBuffer;
+			cartPort.ReadIRQ = Glue_ReadIRQ;
+			cartPort.ReadNMI = cia1.ReadIRQBuffer;
 
-            cassPort.ReadDataOutput = CassPort_ReadDataOutput;
-            cassPort.ReadMotor = CassPort_ReadMotor;
+			cassPort.ReadDataOutput = CassPort_ReadDataOutput;
+			cassPort.ReadMotor = CassPort_ReadMotor;
 
-            cia0.ReadCNT = Cia0_ReadCnt;
-            cia0.ReadFlag = cassPort.ReadDataInputBuffer;
+			cia0.ReadCNT = Cia0_ReadCnt;
+			cia0.ReadFlag = cassPort.ReadDataInputBuffer;
 			cia0.ReadPortA = Cia0_ReadPortA;
 			cia0.ReadPortB = Cia0_ReadPortB;
-            cia0.ReadSP = Cia0_ReadSP;
+			cia0.ReadSP = Cia0_ReadSP;
 
-            cia1.ReadCNT = Cia1_ReadCnt;
-            cia1.ReadFlag = userPort.ReadFlag2;
-            cia1.ReadPortA = Cia1_ReadPortA;
+			cia1.ReadCNT = Cia1_ReadCnt;
+			cia1.ReadFlag = userPort.ReadFlag2;
+			cia1.ReadPortA = Cia1_ReadPortA;
 			cia1.ReadPortB = userPort.ReadData;
-            cia1.ReadSP = Cia1_ReadSP;
+			cia1.ReadSP = Cia1_ReadSP;
 
 			cpu.PeekMemory = pla.Peek;
 			cpu.PokeMemory = pla.Poke;
-            cpu.ReadAEC = vic.ReadAECBuffer;
-            cpu.ReadIRQ = Glue_ReadIRQ;
-            cpu.ReadNMI = cia1.ReadIRQBuffer;
-            cpu.ReadPort = Cpu_ReadPort;
-            cpu.ReadRDY = vic.ReadBABuffer;
-            cpu.ReadMemory = pla.Read;
+			cpu.ReadAEC = vic.ReadAECBuffer;
+			cpu.ReadIRQ = Glue_ReadIRQ;
+			cpu.ReadNMI = cia1.ReadIRQBuffer;
+			cpu.ReadPort = Cpu_ReadPort;
+			cpu.ReadRDY = vic.ReadBABuffer;
+			cpu.ReadMemory = pla.Read;
 			cpu.WriteMemory = pla.Write;
 
 			pla.PeekBasicRom = basicRom.Peek;
@@ -152,93 +154,93 @@ namespace BizHawk.Emulation.Computers.Commodore64
 			pla.PokeMemory = ram.Poke;
 			pla.PokeSid = sid.Poke;
 			pla.PokeVic = vic.Poke;
-            pla.ReadAEC = vic.ReadAECBuffer;
-            pla.ReadBA = vic.ReadBABuffer;
-            pla.ReadBasicRom = basicRom.Read;
-            pla.ReadCartridgeHi = cartPort.ReadHiRom;
-            pla.ReadCartridgeLo = cartPort.ReadLoRom;
-            pla.ReadCharen = Pla_ReadCharen;
-            pla.ReadCharRom = charRom.Read;
-            pla.ReadCia0 = Pla_ReadCia0;
-            pla.ReadCia1 = cia1.Read;
-            pla.ReadColorRam = Pla_ReadColorRam;
-            pla.ReadExpansionHi = cartPort.ReadHiExp;
-            pla.ReadExpansionLo = cartPort.ReadLoExp;
-            pla.ReadExRom = cartPort.ReadExRom;
-            pla.ReadGame = cartPort.ReadGame;
-            pla.ReadHiRam = Pla_ReadHiRam;
-            pla.ReadKernalRom = kernalRom.Read;
-            pla.ReadLoRam = Pla_ReadLoRam;
-            pla.ReadMemory = ram.Read;
-            pla.ReadSid = sid.Read;
-            pla.ReadVic = vic.Read;
-            pla.WriteCartridgeHi = cartPort.WriteHiRom;
-            pla.WriteCartridgeLo = cartPort.WriteLoRom;
-            pla.WriteCia0 = cia0.Write;
-            pla.WriteCia1 = cia1.Write;
-            pla.WriteColorRam = colorRam.Write;
-            pla.WriteExpansionHi = cartPort.WriteHiExp;
-            pla.WriteExpansionLo = cartPort.WriteLoExp;
-            pla.WriteMemory = ram.Write;
-            pla.WriteSid = sid.Write;
-            pla.WriteVic = vic.Write;
+			pla.ReadAEC = vic.ReadAECBuffer;
+			pla.ReadBA = vic.ReadBABuffer;
+			pla.ReadBasicRom = basicRom.Read;
+			pla.ReadCartridgeHi = cartPort.ReadHiRom;
+			pla.ReadCartridgeLo = cartPort.ReadLoRom;
+			pla.ReadCharen = Pla_ReadCharen;
+			pla.ReadCharRom = charRom.Read;
+			pla.ReadCia0 = Pla_ReadCia0;
+			pla.ReadCia1 = cia1.Read;
+			pla.ReadColorRam = Pla_ReadColorRam;
+			pla.ReadExpansionHi = cartPort.ReadHiExp;
+			pla.ReadExpansionLo = cartPort.ReadLoExp;
+			pla.ReadExRom = cartPort.ReadExRom;
+			pla.ReadGame = cartPort.ReadGame;
+			pla.ReadHiRam = Pla_ReadHiRam;
+			pla.ReadKernalRom = kernalRom.Read;
+			pla.ReadLoRam = Pla_ReadLoRam;
+			pla.ReadMemory = ram.Read;
+			pla.ReadSid = sid.Read;
+			pla.ReadVic = vic.Read;
+			pla.WriteCartridgeHi = cartPort.WriteHiRom;
+			pla.WriteCartridgeLo = cartPort.WriteLoRom;
+			pla.WriteCia0 = cia0.Write;
+			pla.WriteCia1 = cia1.Write;
+			pla.WriteColorRam = colorRam.Write;
+			pla.WriteExpansionHi = cartPort.WriteHiExp;
+			pla.WriteExpansionLo = cartPort.WriteLoExp;
+			pla.WriteMemory = ram.Write;
+			pla.WriteSid = sid.Write;
+			pla.WriteVic = vic.Write;
 
-            serPort.ReadAtnOut = SerPort_ReadAtnOut;
-            serPort.ReadClockOut = SerPort_ReadClockOut;
-            serPort.ReadDataOut = SerPort_ReadDataOut;
+			serPort.ReadAtnOut = SerPort_ReadAtnOut;
+			serPort.ReadClockOut = SerPort_ReadClockOut;
+			serPort.ReadDataOut = SerPort_ReadDataOut;
 
-            sid.ReadPotX = Sid_ReadPotX;
-            sid.ReadPotY = Sid_ReadPotY;
+			sid.ReadPotX = Sid_ReadPotX;
+			sid.ReadPotY = Sid_ReadPotY;
 
-            vic.ReadMemory = Vic_ReadMemory;
-            vic.ReadColorRam = colorRam.Read;
+			vic.ReadMemory = Vic_ReadMemory;
+			vic.ReadColorRam = colorRam.Read;
 		}
 
 		public void SyncState(Serializer ser)
 		{
-            ser.BeginSection("motherboard");
-            SaveState.SyncObject(ser, this);
-            ser.EndSection();
+			ser.BeginSection("motherboard");
+			SaveState.SyncObject(ser, this);
+			ser.EndSection();
 
-            ser.BeginSection("cartridge");
-            cartPort.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("cartridge");
+			cartPort.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("cassette");
-            cassPort.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("cassette");
+			cassPort.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("cia0");
-            cia0.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("cia0");
+			cia0.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("cia1");
-            cia1.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("cia1");
+			cia1.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("colorram");
-            colorRam.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("colorram");
+			colorRam.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("cpu");
-            cpu.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("cpu");
+			cpu.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("pla");
-            pla.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("pla");
+			pla.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("ram");
-            ram.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("ram");
+			ram.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("sid");
-            sid.SyncState(ser);
-            ser.EndSection();
+			ser.BeginSection("sid");
+			sid.SyncState(ser);
+			ser.EndSection();
 
-            ser.BeginSection("vic");
-            vic.SyncState(ser);
-            ser.EndSection();
-        }
+			ser.BeginSection("vic");
+			vic.SyncState(ser);
+			ser.EndSection();
+		}
 	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/C64.Savestate.cs b/BizHawk.Emulation/Computers/Commodore64/C64.Savestate.cs
index cce2af2d93..b71192e7dc 100644
--- a/BizHawk.Emulation/Computers/Commodore64/C64.Savestate.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/C64.Savestate.cs
@@ -1,5 +1,7 @@
 using System.IO;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64
 {
 	sealed public partial class C64 : IEmulator
@@ -51,9 +53,9 @@ namespace BizHawk.Emulation.Computers.Commodore64
 
 		void SyncState(Serializer ser)
 		{
-            ser.BeginSection("core");
-            board.SyncState(ser);
-            ser.EndSection();
-        }
+			ser.BeginSection("core");
+			board.SyncState(ser);
+			ser.EndSection();
+		}
 	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Cart.cs b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Cart.cs
index e8f949b463..b87de86028 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Cart.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Cart.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Cartridge
 {
 	// this is the base cartridge class
@@ -236,7 +238,7 @@ namespace BizHawk.Emulation.Computers.Commodore64.Cartridge
 
 		public virtual void SyncState(Serializer ser)
 		{
-            SaveState.SyncObject(ser, this);
+			SaveState.SyncObject(ser, this);
 		}
 
 		public bool Valid
diff --git a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0005.cs b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0005.cs
index ed19cb205b..c2be6f2980 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0005.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0005.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Cartridge
 {
 	public class Mapper0005 : Cart
diff --git a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper000F.cs b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper000F.cs
index c62422b85b..a33686205e 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper000F.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper000F.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Cartridge
 {
 	// This is a mapper used commonly by System 3. It is
diff --git a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0012.cs b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0012.cs
index c6d64b9001..40b4c0f561 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0012.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0012.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Cartridge
 {
 	public class Mapper0012 : Cart
diff --git a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0013.cs b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0013.cs
index 4d343b4e6d..eafa460753 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0013.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0013.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.Cartridge
 {
diff --git a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0020.cs b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0020.cs
index 48438ca6a6..eddb69b50f 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0020.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Cartridge/Mapper0020.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.Cartridge
 {
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cassette.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cassette.cs
index 60c3ee25fb..90eca4a3ae 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cassette.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cassette.cs
@@ -3,17 +3,19 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    public class Cassette
-    {
-        public Func<bool> InputData;
-        public Func<bool> InputMotor;
+	public class Cassette
+	{
+		public Func<bool> InputData;
+		public Func<bool> InputMotor;
 
-        virtual public bool Data { get { return true; } }
-        public bool OutputData() { return Data; }
-        public bool OutputSense() { return Sense; }
-        virtual public bool Sense { get { return true; } }
-        virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+		virtual public bool Data { get { return true; } }
+		public bool OutputData() { return Data; }
+		public bool OutputSense() { return Sense; }
+		virtual public bool Sense { get { return true; } }
+		virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cia.Interface.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cia.Interface.cs
index 66e65fbbef..525d813307 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cia.Interface.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cia.Interface.cs
@@ -3,31 +3,33 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    sealed public partial class Cia
-    {
-        public Func<bool> InputCNT;
-        public Func<bool> InputFlag;
-        public Func<int> InputPortA;
-        public Func<int> InputPortB;
-        public Func<bool> InputSP;
+	sealed public partial class Cia
+	{
+		public Func<bool> InputCNT;
+		public Func<bool> InputFlag;
+		public Func<int> InputPortA;
+		public Func<int> InputPortB;
+		public Func<bool> InputSP;
 
-        public bool CNT { get { return true; } }
-        public bool IRQ { get { return true; } }
-        public bool OutputCNT() { return CNT; }
-        public bool OutputIRQ() { return IRQ; }
-        public bool OutputPC() { return PC; }
-        public int OutputPortA() { return PortA; }
-        public int OutputPortB() { return PortB; }
-        public bool OutputSP() { return SP; }
-        public bool PC { get { return true; } }
-        public int PortA { get { return 0xFF; } }
-        public int PortB { get { return 0xFF; } }
-        public bool PortA0 { get { return true; } }
-        public bool SP { get { return true; } }
+		public bool CNT { get { return true; } }
+		public bool IRQ { get { return true; } }
+		public bool OutputCNT() { return CNT; }
+		public bool OutputIRQ() { return IRQ; }
+		public bool OutputPC() { return PC; }
+		public int OutputPortA() { return PortA; }
+		public int OutputPortB() { return PortB; }
+		public bool OutputSP() { return SP; }
+		public bool PC { get { return true; } }
+		public int PortA { get { return 0xFF; } }
+		public int PortB { get { return 0xFF; } }
+		public bool PortA0 { get { return true; } }
+		public bool SP { get { return true; } }
 
-        public void Clock() { }
-        public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+		public void Clock() { }
+		public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cpu.Interface.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cpu.Interface.cs
index 2a54f4f528..d38cf735ca 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cpu.Interface.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cpu.Interface.cs
@@ -3,36 +3,38 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    sealed public partial class Cpu
-    {
-        public Func<bool> InputAEC;
-        public Func<bool> InputIRQ;
-        public Func<bool> InputNMI;
-        public Func<int> InputPort;
-        public Func<bool> InputRDY;
-        public Func<int, int> ReadMemory;
-        public Action<int, int> WriteMemory;
+	sealed public partial class Cpu
+	{
+		public Func<bool> InputAEC;
+		public Func<bool> InputIRQ;
+		public Func<bool> InputNMI;
+		public Func<int> InputPort;
+		public Func<bool> InputRDY;
+		public Func<int, int> ReadMemory;
+		public Action<int, int> WriteMemory;
 
-        public int OutputPort() { return Port; }
-        public bool OutputPort0() { return Port0; }
-        public bool OutputPort1() { return Port1; }
-        public bool OutputPort2() { return Port2; }
-        public bool OutputPort3() { return Port3; }
-        public bool OutputPort4() { return Port4; }
-        public bool OutputPort5() { return Port5; }
-        public bool OutputPort6() { return Port6; }
-        public bool OutputPort7() { return Port7; }
-        public int Port { get { return (portLatch | (~portDirection)) & 0xFF; } }
-        public bool Port0 { get { return (Port & 0x01) != 0; } }
-        public bool Port1 { get { return (Port & 0x02) != 0; } }
-        public bool Port2 { get { return (Port & 0x04) != 0; } }
-        public bool Port3 { get { return (Port & 0x08) != 0; } }
-        public bool Port4 { get { return (Port & 0x10) != 0; } }
-        public bool Port5 { get { return (Port & 0x20) != 0; } }
-        public bool Port6 { get { return (Port & 0x40) != 0; } }
-        public bool Port7 { get { return (Port & 0x80) != 0; } }
-        public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+		public int OutputPort() { return Port; }
+		public bool OutputPort0() { return Port0; }
+		public bool OutputPort1() { return Port1; }
+		public bool OutputPort2() { return Port2; }
+		public bool OutputPort3() { return Port3; }
+		public bool OutputPort4() { return Port4; }
+		public bool OutputPort5() { return Port5; }
+		public bool OutputPort6() { return Port6; }
+		public bool OutputPort7() { return Port7; }
+		public int Port { get { return (portLatch | (~portDirection)) & 0xFF; } }
+		public bool Port0 { get { return (Port & 0x01) != 0; } }
+		public bool Port1 { get { return (Port & 0x02) != 0; } }
+		public bool Port2 { get { return (Port & 0x04) != 0; } }
+		public bool Port3 { get { return (Port & 0x08) != 0; } }
+		public bool Port4 { get { return (Port & 0x10) != 0; } }
+		public bool Port5 { get { return (Port & 0x20) != 0; } }
+		public bool Port6 { get { return (Port & 0x40) != 0; } }
+		public bool Port7 { get { return (Port & 0x80) != 0; } }
+		public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Expansion.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Expansion.cs
index 8dfbf1cde7..4124ecc69d 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Expansion.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Expansion.cs
@@ -3,18 +3,20 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    public class Expansion
-    {
-        virtual public bool ExRom { get { return true; } }
-        virtual public bool Game { get { return true; } }
-        virtual public bool IRQ { get { return true; } }
-        virtual public bool NMI { get { return true; } }
-        public bool OutputExRom() { return ExRom; }
-        public bool OutputGame() { return Game; }
-        public bool OutputIRQ() { return IRQ; }
-        public bool OutputNMI() { return NMI; }
-        virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+	public class Expansion
+	{
+		virtual public bool ExRom { get { return true; } }
+		virtual public bool Game { get { return true; } }
+		virtual public bool IRQ { get { return true; } }
+		virtual public bool NMI { get { return true; } }
+		public bool OutputExRom() { return ExRom; }
+		public bool OutputGame() { return Game; }
+		public bool OutputIRQ() { return IRQ; }
+		public bool OutputNMI() { return NMI; }
+		virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Joystick.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Joystick.cs
index 6e060cd8ab..8144204dc5 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Joystick.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Joystick.cs
@@ -3,14 +3,16 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    public class Joystick
-    {
-        virtual public int Data { get { return 0xFF; } }
-        public int OutputData() { return Data; }
-        public int OutputPot() { return Pot; }
-        virtual public int Pot { get { return 0xFF; } }
-        virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+	public class Joystick
+	{
+		virtual public int Data { get { return 0xFF; } }
+		public int OutputData() { return Data; }
+		public int OutputPot() { return Pot; }
+		virtual public int Pot { get { return 0xFF; } }
+		virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Keyboard.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Keyboard.cs
index 64a2218ee4..2ad3978377 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Keyboard.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Keyboard.cs
@@ -3,16 +3,18 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    public class Keyboard
-    {
-        virtual public int Column { get { return 0xFF; } }
-        public int OutputColumn() { return Column; }
-        public bool OutputRestore() { return Restore; }
-        public int OutputRow() { return Row; }
-        virtual public bool Restore { get { return true; } }
-        virtual public int Row { get { return 0xFF; } }
-        virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+	public class Keyboard
+	{
+		virtual public int Column { get { return 0xFF; } }
+		public int OutputColumn() { return Column; }
+		public bool OutputRestore() { return Restore; }
+		public int OutputRow() { return Row; }
+		virtual public bool Restore { get { return true; } }
+		virtual public int Row { get { return 0xFF; } }
+		virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Ram.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Ram.cs
index 7858a9ba3b..b1333f06ac 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Ram.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Ram.cs
@@ -3,41 +3,43 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    sealed public class Ram
-    {
-        int addressMask;
-        int dataMask;
-        int[] memory;
+	sealed public class Ram
+	{
+		int addressMask;
+		int dataMask;
+		int[] memory;
 
-        public Ram(int size, int addressMask, int dataMask)
-        {
-            this.addressMask = addressMask;
-            this.dataMask = dataMask;
-            this.memory = new int[size];
-        }
+		public Ram(int size, int addressMask, int dataMask)
+		{
+			this.addressMask = addressMask;
+			this.dataMask = dataMask;
+			this.memory = new int[size];
+		}
 
-        public int Peek(int addr)
-        {
-            return memory[addr & addressMask];
-        }
+		public int Peek(int addr)
+		{
+			return memory[addr & addressMask];
+		}
 
-        public void Poke(int addr, int val)
-        {
-            memory[addr & addressMask] = val;
-        }
+		public void Poke(int addr, int val)
+		{
+			memory[addr & addressMask] = val;
+		}
 
-        public int Read(int addr)
-        {
-            return memory[addr & addressMask];
-        }
+		public int Read(int addr)
+		{
+			return memory[addr & addressMask];
+		}
 
-        public void Write(int addr, int val)
-        {
-            memory[addr & addressMask] = val & dataMask;
-        }
+		public void Write(int addr, int val)
+		{
+			memory[addr & addressMask] = val & dataMask;
+		}
 
-        public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+		public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Rom.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Rom.cs
index 5e5a541f11..c341e60a2a 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Rom.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Rom.cs
@@ -3,31 +3,33 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    public class Rom
-    {
-        int addressMask;
-        int[] memory;
+	public class Rom
+	{
+		int addressMask;
+		int[] memory;
 
-        public Rom(int size, int addressMask, byte[] data)
-        {
-            this.addressMask = addressMask;
-            this.memory = new int[size];
-            for (int i = 0; i < size; i++)
-                memory[i] = data[i];
-        }
+		public Rom(int size, int addressMask, byte[] data)
+		{
+			this.addressMask = addressMask;
+			this.memory = new int[size];
+			for (int i = 0; i < size; i++)
+				memory[i] = data[i];
+		}
 
-        public int Peek(int addr)
-        {
-            return memory[addr & addressMask];
-        }
+		public int Peek(int addr)
+		{
+			return memory[addr & addressMask];
+		}
 
-        public int Read(int addr)
-        {
-            return memory[addr & addressMask];
-        }
+		public int Read(int addr)
+		{
+			return memory[addr & addressMask];
+		}
 
-        public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+		public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Serial.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Serial.cs
index 87fffa2426..5273e5defd 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Serial.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Serial.cs
@@ -3,21 +3,23 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    public class Serial
-    {
-        public Func<bool> InputATN;
-        public Func<bool> InputClock;
-        public Func<bool> InputData;
-        public Func<bool> InputReset;
+	public class Serial
+	{
+		public Func<bool> InputATN;
+		public Func<bool> InputClock;
+		public Func<bool> InputData;
+		public Func<bool> InputReset;
 
-        virtual public bool Clock { get { return true; } }
-        virtual public bool Data { get { return true; } }
-        public bool OutputClock() { return Clock; }
-        public bool OutputData() { return Data; }
-        public bool OutputSRQ() { return SRQ; }
-        virtual public bool SRQ { get { return true; } }
-        virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
-    }
+		virtual public bool Clock { get { return true; } }
+		virtual public bool Data { get { return true; } }
+		public bool OutputClock() { return Clock; }
+		public bool OutputData() { return Data; }
+		public bool OutputSRQ() { return SRQ; }
+		virtual public bool SRQ { get { return true; } }
+		virtual public void SyncState(Serializer ser) { SaveState.SyncObject(ser, this); }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Sid.Interface.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Sid.Interface.cs
index 38caec7fa6..3e62973037 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Sid.Interface.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Sid.Interface.cs
@@ -3,10 +3,12 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    sealed public partial class Sid
-    {
-        public void SyncState(Serializer ser) { }
-    }
+	sealed public partial class Sid
+	{
+		public void SyncState(Serializer ser) { }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.State.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.State.cs
index e3f1e052d2..fb9c94d1a7 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.State.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.State.cs
@@ -3,12 +3,14 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    sealed public partial class Vic
-    {
-        public void SyncState(Serializer ser)
-        {
-        }
-    }
+	sealed public partial class Vic
+	{
+		public void SyncState(Serializer ser)
+		{
+		}
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.VideoProvider.cs b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.VideoProvider.cs
index c6bf80ab7a..e0edcc4cd6 100644
--- a/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.VideoProvider.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.VideoProvider.cs
@@ -3,18 +3,20 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 #pragma warning disable 649 //adelikat: Disable dumb warnings until this file is complete
 
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    sealed public partial class Vic : IVideoProvider
-    {
-        int screenHeight;
-        int screenWidth;
-        int[] videoBuffer;
+	sealed public partial class Vic : IVideoProvider
+	{
+		int screenHeight;
+		int screenWidth;
+		int[] videoBuffer;
 
-        // palette
-        static private int[] palette =
+		// palette
+		static private int[] palette =
         {
                 Colors.ARGB(0x00, 0x00, 0x00),
                 Colors.ARGB(0xFF, 0xFF, 0xFF),
@@ -34,29 +36,29 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
                 Colors.ARGB(0x95, 0x95, 0x95)
         };
 
-        public int[] GetVideoBuffer()
-        {
-            return videoBuffer;
-        }
+		public int[] GetVideoBuffer()
+		{
+			return videoBuffer;
+		}
 
-        public int VirtualWidth
-        {
-            get { return screenWidth; }
-        }
+		public int VirtualWidth
+		{
+			get { return screenWidth; }
+		}
 
-        public int BufferWidth
-        {
-            get { return screenWidth; }
-        }
+		public int BufferWidth
+		{
+			get { return screenWidth; }
+		}
 
-        public int BufferHeight
-        {
-            get { return screenHeight; }
-        }
+		public int BufferHeight
+		{
+			get { return screenHeight; }
+		}
 
-        public int BackgroundColor
-        {
-            get { return palette[0]; }
-        }
-    }
+		public int BackgroundColor
+		{
+			get { return palette[0]; }
+		}
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/CartridgePort.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/CartridgePort.cs
index e30f8baf00..70a8898647 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/CartridgePort.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/CartridgePort.cs
@@ -1,15 +1,17 @@
 using System;
+
+using BizHawk.Common;
 using BizHawk.Emulation.Computers.Commodore64.Cartridge;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
 	sealed public class CartridgePort
 	{
-        public Func<bool> ReadIRQ;
-        public Func<bool> ReadNMI;
+		public Func<bool> ReadIRQ;
+		public Func<bool> ReadNMI;
 
 		Cart cart;
-        bool connected;
+		bool connected;
 
 		public CartridgePort()
 		{
@@ -29,9 +31,9 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 		public void PokeLoExp(int addr, byte val) { if (connected) { cart.PokeDE00(addr & 0x00FF, val); } }
 		public void PokeLoRom(int addr, byte val) { if (connected) { cart.Poke8000(addr & 0x1FFF, val); } }
 
-        public bool ReadExRom() { if (connected) { return cart.ExRom; } else { return true; } }
-        public bool ReadGame() { if (connected) { return cart.Game; } else { return true; } }
-        public byte ReadHiExp(int addr) { if (connected) { return cart.ReadDF00((addr & 0x00FF)); } else { return 0xFF; } }
+		public bool ReadExRom() { if (connected) { return cart.ExRom; } else { return true; } }
+		public bool ReadGame() { if (connected) { return cart.Game; } else { return true; } }
+		public byte ReadHiExp(int addr) { if (connected) { return cart.ReadDF00((addr & 0x00FF)); } else { return 0xFF; } }
 		public byte ReadHiRom(int addr) { if (connected) { return cart.ReadA000((addr & 0x1FFF)); } else { return 0xFF; } }
 		public byte ReadLoExp(int addr) { if (connected) { return cart.ReadDE00((addr & 0x00FF)); } else { return 0xFF; } }
 		public byte ReadLoRom(int addr) { if (connected) { return cart.Read8000((addr & 0x1FFF)); } else { return 0xFF; } }
@@ -68,19 +70,19 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 			}
 		}
 
-        public bool ReadIRQBuffer()
-        {
-            return true;
-        }
-
-        public bool ReadNMIBuffer()
-        {
-            return true;
-        }
-
-        public void SyncState(Serializer ser)
+		public bool ReadIRQBuffer()
 		{
-            SaveState.SyncObject(ser, this);
+			return true;
+		}
+
+		public bool ReadNMIBuffer()
+		{
+			return true;
+		}
+
+		public void SyncState(Serializer ser)
+		{
+			SaveState.SyncObject(ser, this);
 		}
 	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/CassettePort.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/CassettePort.cs
index 6da8aa8a15..069db6bea5 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/CassettePort.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/CassettePort.cs
@@ -1,29 +1,30 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
 	public class CassettePort
 	{
-        public Func<bool> ReadDataOutput;
-        public Func<bool> ReadMotor;
+		public Func<bool> ReadDataOutput;
+		public Func<bool> ReadMotor;
 
 		public void HardReset()
 		{
 		}
 
-        virtual public bool ReadDataInputBuffer()
-        {
-            return true;
-        }
+		virtual public bool ReadDataInputBuffer()
+		{
+			return true;
+		}
 
-        virtual public bool ReadSenseBuffer()
-        {
-            return true;
-        }
+		virtual public bool ReadSenseBuffer()
+		{
+			return true;
+		}
 
-        public void SyncState(Serializer ser)
-        {
-            SaveState.SyncObject(ser, this);
-        }
+		public void SyncState(Serializer ser)
+		{
+			SaveState.SyncObject(ser, this);
+		}
 	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Chip2114.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Chip2114.cs
index 8a693848a2..0f47ce0c88 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Chip2114.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Chip2114.cs
@@ -1,10 +1,12 @@
-namespace BizHawk.Emulation.Computers.Commodore64.MOS
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
 	// used as Color RAM in C64
 
 	sealed public class Chip2114
 	{
-        byte[] ram;
+		byte[] ram;
 
 		public Chip2114()
 		{
@@ -31,15 +33,15 @@
 			return ram[addr & 0x3FF];
 		}
 
-        public int ReadInt(int addr)
-        {
-            return ram[addr & 0x3FF];
-        }
+		public int ReadInt(int addr)
+		{
+			return ram[addr & 0x3FF];
+		}
 
 		public void SyncState(Serializer ser)
 		{
-            SaveState.SyncObject(ser, this);
-        }
+			SaveState.SyncObject(ser, this);
+		}
 
 		public void Write(int addr, byte val)
 		{
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Chip23XX.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Chip23XX.cs
index 69c04922a7..e1cdb39842 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Chip23XX.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Chip23XX.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
@@ -53,7 +54,7 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 
 		public void SyncState(Serializer ser)
 		{
-            SaveState.SyncObject(ser, this);
+			SaveState.SyncObject(ser, this);
         }
 	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Chip4864.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Chip4864.cs
index 51bdd70e90..83afb637ae 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Chip4864.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Chip4864.cs
@@ -1,19 +1,21 @@
-namespace BizHawk.Emulation.Computers.Commodore64.MOS
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
 	// DRAM for the c64
 	// 4164 = 64 kbit
 	// 4464 = 256 kbit
 	// 4864 = 512 kbit
-	
+
 	// for purposes of simplification we'll just
 	// use one 4864, the C64 can use sets of 4164 or
 	// 4464 typically
 
 	// memory is striped 00/FF at intervals of 0x40
 
-    sealed public class Chip4864
+	sealed public class Chip4864
 	{
-        byte[] ram;
+		byte[] ram;
 
 		public Chip4864()
 		{
@@ -35,22 +37,22 @@
 
 		public void Poke(int addr, byte val)
 		{
-            ram[addr] = val;
+			ram[addr] = val;
 		}
 
 		public byte Read(int addr)
 		{
-            return ram[addr];
+			return ram[addr];
 		}
 
 		public void SyncState(Serializer ser)
 		{
-            SaveState.SyncObject(ser, this);
-        }
+			SaveState.SyncObject(ser, this);
+		}
 
 		public void Write(int addr, byte val)
 		{
-            ram[addr] = val;
+			ram[addr] = val;
 		}
 	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/MOS6510.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/MOS6510.cs
index a7fb20ebd0..ea6dbf38e7 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/MOS6510.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/MOS6510.cs
@@ -3,18 +3,20 @@ using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
 	// an extension of the 6502 processor
 
-    sealed public class MOS6510
+	sealed public class MOS6510
 	{
 		// ------------------------------------
 
-        MOS6502X cpu;
-        bool pinNMILast;
-        LatchedPort port;
-        bool thisNMI;
+		MOS6502X cpu;
+		bool pinNMILast;
+		LatchedPort port;
+		bool thisNMI;
 
 		public Func<int, byte> PeekMemory;
 		public Action<int, byte> PokeMemory;
@@ -23,65 +25,65 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 		public Func<bool> ReadNMI;
 		public Func<bool> ReadRDY;
 		public Func<int, byte> ReadMemory;
-        public Func<byte> ReadPort;
+		public Func<byte> ReadPort;
 		public Action<int, byte> WriteMemory;
 
 		// ------------------------------------
 
 		public MOS6510()
 		{
-            cpu = new MOS6502X();
+			cpu = new MOS6502X();
 
 			// configure cpu r/w
 			cpu.DummyReadMemory = Read;
 			cpu.ReadMemory = Read;
 			cpu.WriteMemory = Write;
 
-            // perform hard reset
-            HardReset();
+			// perform hard reset
+			HardReset();
 		}
 
 		public void HardReset()
 		{
-            // configure CPU defaults
+			// configure CPU defaults
 			cpu.Reset();
 			cpu.FlagI = true;
 			cpu.BCD_Enabled = true;
-            if (ReadMemory != null)
-			    cpu.PC = (ushort)(ReadMemory(0x0FFFC) | (ReadMemory(0x0FFFD) << 8));
+			if (ReadMemory != null)
+				cpu.PC = (ushort)(ReadMemory(0x0FFFC) | (ReadMemory(0x0FFFD) << 8));
 
-            // configure data port defaults
-            port = new LatchedPort();
-            port.Direction = 0x00;
-            port.Latch = 0xFF;
+			// configure data port defaults
+			port = new LatchedPort();
+			port.Direction = 0x00;
+			port.Latch = 0xFF;
 
-            // NMI is high on startup (todo: verify)
-            pinNMILast = true;
-        }
+			// NMI is high on startup (todo: verify)
+			pinNMILast = true;
+		}
 
 		// ------------------------------------
 
 		public void ExecutePhase1()
 		{
-            cpu.IRQ = !ReadIRQ();
-        }
+			cpu.IRQ = !ReadIRQ();
+		}
 
 		public void ExecutePhase2()
 		{
-            cpu.RDY = ReadRDY();
+			cpu.RDY = ReadRDY();
 
-            // the 6502 core expects active high
-            // so we reverse the polarity here
-            thisNMI = ReadNMI();
-            if (!thisNMI && pinNMILast)
-                cpu.NMI = true;
+			// the 6502 core expects active high
+			// so we reverse the polarity here
+			thisNMI = ReadNMI();
+			if (!thisNMI && pinNMILast)
+				cpu.NMI = true;
 
-            if (ReadAEC())
-            {
-                cpu.ExecuteOne();
-                pinNMILast = thisNMI;
-            }
-        }
+			if (ReadAEC())
+			{
+				cpu.ExecuteOne();
+				pinNMILast = thisNMI;
+			}
+		}
 
 		// ------------------------------------
 
@@ -91,10 +93,10 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 			{
 				return cpu.PC;
 			}
-            set
-            {
-                cpu.PC = value;
-            }
+			set
+			{
+				cpu.PC = value;
+			}
 		}
 
 		public byte Peek(int addr)
@@ -109,7 +111,7 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 
 		public void Poke(int addr, byte val)
 		{
-            if (addr == 0x0000)
+			if (addr == 0x0000)
 				port.Direction = val;
 			else if (addr == 0x0001)
 				port.Latch = val;
@@ -117,19 +119,19 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 				PokeMemory(addr, val);
 		}
 
-        public byte PortData
-        {
-            get
-            {
-                return port.ReadInput(ReadPort());
-            }
-            set
-            {
-                port.Latch = value;
-            }
-        }
+		public byte PortData
+		{
+			get
+			{
+				return port.ReadInput(ReadPort());
+			}
+			set
+			{
+				port.Latch = value;
+			}
+		}
 
-        public byte Read(ushort addr)
+		public byte Read(ushort addr)
 		{
 			if (addr == 0x0000)
 				return port.Direction;
@@ -139,13 +141,13 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 				return ReadMemory(addr);
 		}
 
-        public void SyncState(Serializer ser)
-        {
-            cpu.SyncState(ser);
-            SaveState.SyncObject(ser, this);
-        }
+		public void SyncState(Serializer ser)
+		{
+			cpu.SyncState(ser);
+			SaveState.SyncObject(ser, this);
+		}
 
-        public void Write(ushort addr, byte val)
+		public void Write(ushort addr, byte val)
 		{
 			if (addr == 0x0000)
 				port.Direction = val;
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/MOS6526.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/MOS6526.cs
index e9fa2e1a6c..5a61e239b4 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/MOS6526.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/MOS6526.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/MOSPLA.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/MOSPLA.cs
index 2c950f0d44..91029579e9 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/MOSPLA.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/MOSPLA.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Port.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Port.cs
index fa02d8efa3..eef6ed3ea0 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Port.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Port.cs
@@ -1,84 +1,85 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
-    sealed public class LatchedPort
-    {
-        public byte Direction;
-        public byte Latch;
+	sealed public class LatchedPort
+	{
+		public byte Direction;
+		public byte Latch;
 
-        public LatchedPort()
-        {
-            Direction = 0x00;
-            Latch = 0x00;
-        }
+		public LatchedPort()
+		{
+			Direction = 0x00;
+			Latch = 0x00;
+		}
 
-        // data works like this in these types of systems:
-        // 
-        //  directionA  directionB  result
-        //  0           0           1
-        //  1           0           latchA
-        //  0           1           latchB
-        //  1           1           latchA && latchB
-        //
-        // however because this uses transistor logic, there are cases where wired-ands
-        // cause the pull-up resistors not to be enough to keep the bus bit set to 1 when
-        // both the direction and latch are 1 (the keyboard and joystick port 2 can do this.)
-        // the class does not handle this case as it must be handled differently in every occurrence.
+		// data works like this in these types of systems:
+		// 
+		//  directionA  directionB  result
+		//  0           0           1
+		//  1           0           latchA
+		//  0           1           latchB
+		//  1           1           latchA && latchB
+		//
+		// however because this uses transistor logic, there are cases where wired-ands
+		// cause the pull-up resistors not to be enough to keep the bus bit set to 1 when
+		// both the direction and latch are 1 (the keyboard and joystick port 2 can do this.)
+		// the class does not handle this case as it must be handled differently in every occurrence.
 
-        public byte ReadInput(byte bus)
-        {
-            return (byte)((Latch & Direction) | ((Direction ^ 0xFF) & bus));
-        }
+		public byte ReadInput(byte bus)
+		{
+			return (byte)((Latch & Direction) | ((Direction ^ 0xFF) & bus));
+		}
 
-        public byte ReadOutput()
-        {
-            return (byte)((Latch & Direction) | (Direction ^ 0xFF));
-        }
+		public byte ReadOutput()
+		{
+			return (byte)((Latch & Direction) | (Direction ^ 0xFF));
+		}
 
-        public void SyncState(Serializer ser)
-        {
-            SaveState.SyncObject(ser, this);
-        }
-    }
+		public void SyncState(Serializer ser)
+		{
+			SaveState.SyncObject(ser, this);
+		}
+	}
 
-    sealed public class LatchedBooleanPort
-    {
-        public bool Direction;
-        public bool Latch;
+	sealed public class LatchedBooleanPort
+	{
+		public bool Direction;
+		public bool Latch;
 
-        public LatchedBooleanPort()
-        {
-            Direction = false;
-            Latch = false;
-        }
+		public LatchedBooleanPort()
+		{
+			Direction = false;
+			Latch = false;
+		}
 
-        //  data    dir     bus     out
-        //  0       0       0       0
-        //  0       0       1       1
+		//  data    dir     bus     out
+		//  0       0       0       0
+		//  0       0       1       1
 
-        //  0       1       0       0
-        //  0       1       1       0
+		//  0       1       0       0
+		//  0       1       1       0
 
-        //  1       0       0       0
-        //  1       0       1       1
+		//  1       0       0       0
+		//  1       0       1       1
 
-        //  1       1       0       1
-        //  1       1       1       1
+		//  1       1       0       1
+		//  1       1       1       1
 
-        public bool ReadInput(bool bus)
-        {
-            return (Direction && Latch) || (!Direction && bus);
-        }
+		public bool ReadInput(bool bus)
+		{
+			return (Direction && Latch) || (!Direction && bus);
+		}
 
-        public bool ReadOutput()
-        {
-            return (Latch || !Direction);
-        }
+		public bool ReadOutput()
+		{
+			return (Latch || !Direction);
+		}
 
-        public void SyncState(Serializer ser)
-        {
-            SaveState.SyncObject(ser, this);
-        }
-    }
+		public void SyncState(Serializer ser)
+		{
+			SaveState.SyncObject(ser, this);
+		}
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/SerialPort.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/SerialPort.cs
index 4550650092..3e8a5af14a 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/SerialPort.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/SerialPort.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
@@ -7,9 +8,9 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 
 	sealed public class SerialPort
 	{
-        public Func<bool> ReadAtnOut;
-        public Func<bool> ReadClockOut;
-        public Func<bool> ReadDataOut;
+		public Func<bool> ReadAtnOut;
+		public Func<bool> ReadClockOut;
+		public Func<bool> ReadDataOut;
 
 		public SerialPort()
 		{
@@ -19,19 +20,19 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 		{
 		}
 
-        public void SyncState(Serializer ser)
-        {
-            SaveState.SyncObject(ser, this);
-        }
+		public void SyncState(Serializer ser)
+		{
+			SaveState.SyncObject(ser, this);
+		}
 
-        public bool WriteClockIn()
-        {
-            return true;
-        }
+		public bool WriteClockIn()
+		{
+			return true;
+		}
 
-        public bool WriteDataIn()
-        {
-            return true;
-        }
+		public bool WriteDataIn()
+		{
+			return true;
+		}
 	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.Envelope.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.Envelope.cs
index 4836c1cc47..711c2b58ed 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.Envelope.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.Envelope.cs
@@ -3,31 +3,33 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
-    sealed public partial class Sid
-    {
-        sealed class Envelope
-        {
-            const int stateAttack = 0;
-            const int stateDecay = 1;
-            const int stateRelease = 2;
+	sealed public partial class Sid
+	{
+		sealed class Envelope
+		{
+			const int stateAttack = 0;
+			const int stateDecay = 1;
+			const int stateRelease = 2;
 
-            int attack;
-            int decay;
-            bool delay;
-            int envCounter;
-            int expCounter;
-            int expPeriod;
-            bool freeze;
-            int lfsr;
-            bool gate;
-            int rate;
-            int release;
-            int state;
-            int sustain;
+			int attack;
+			int decay;
+			bool delay;
+			int envCounter;
+			int expCounter;
+			int expPeriod;
+			bool freeze;
+			int lfsr;
+			bool gate;
+			int rate;
+			int release;
+			int state;
+			int sustain;
 
-            static int[] adsrTable = new int[]
+			static int[] adsrTable = new int[]
 			{
 				0x7F00, 0x0006, 0x003C, 0x0330,
 				0x20C0, 0x6755, 0x3800, 0x500E,
@@ -35,217 +37,217 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 				0x3840, 0x77E2, 0x7625, 0x0A93
 			};
 
-            static int[] expCounterTable = new int[]
+			static int[] expCounterTable = new int[]
 			{
 				0xFF, 0x5D, 0x36, 0x1A, 0x0E, 0x06, 0x00
 			};
 
-            static int[] expPeriodTable = new int[]
+			static int[] expPeriodTable = new int[]
 			{
 				0x01, 0x02, 0x04, 0x08, 0x10, 0x1E, 0x01
 			};
 
-            static int[] sustainTable = new int[]
+			static int[] sustainTable = new int[]
 			{
 				0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
 				0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
 			};
 
-            public Envelope()
-            {
-                HardReset();
-            }
+			public Envelope()
+			{
+				HardReset();
+			}
 
-            public void ExecutePhase2()
-            {
+			public void ExecutePhase2()
+			{
 
-                {
-                    if (!delay)
-                    {
-                        envCounter--;
-                        delay = true;
-                        UpdateExpCounter();
-                    }
+				{
+					if (!delay)
+					{
+						envCounter--;
+						delay = true;
+						UpdateExpCounter();
+					}
 
-                    if (lfsr != rate)
-                    {
-                        int feedback = ((lfsr >> 14) ^ (lfsr >> 13)) & 0x1;
-                        lfsr = ((lfsr << 1) & 0x7FFF) | feedback;
-                        return;
-                    }
-                    lfsr = 0x7FFF;
+					if (lfsr != rate)
+					{
+						int feedback = ((lfsr >> 14) ^ (lfsr >> 13)) & 0x1;
+						lfsr = ((lfsr << 1) & 0x7FFF) | feedback;
+						return;
+					}
+					lfsr = 0x7FFF;
 
-                    if (state == stateAttack || ++expCounter == expPeriod)
-                    {
-                        expCounter = 0;
-                        if (freeze)
-                            return;
+					if (state == stateAttack || ++expCounter == expPeriod)
+					{
+						expCounter = 0;
+						if (freeze)
+							return;
 
-                        switch (state)
-                        {
-                            case stateAttack:
-                                envCounter++;
-                                if (envCounter == 0xFF)
-                                {
-                                    state = stateDecay;
-                                    rate = adsrTable[decay];
-                                }
-                                break;
-                            case stateDecay:
-                                if (envCounter == sustainTable[sustain])
-                                {
-                                    return;
-                                }
-                                if (expPeriod != 1)
-                                {
-                                    delay = false;
-                                    return;
-                                }
-                                envCounter--;
-                                break;
-                            case stateRelease:
-                                if (expPeriod != 1)
-                                {
-                                    delay = false;
-                                    return;
-                                }
-                                envCounter--;
-                                break;
-                        }
-                        envCounter &= 0xFF;
-                        UpdateExpCounter();
-                    }
-                }
-            }
+						switch (state)
+						{
+							case stateAttack:
+								envCounter++;
+								if (envCounter == 0xFF)
+								{
+									state = stateDecay;
+									rate = adsrTable[decay];
+								}
+								break;
+							case stateDecay:
+								if (envCounter == sustainTable[sustain])
+								{
+									return;
+								}
+								if (expPeriod != 1)
+								{
+									delay = false;
+									return;
+								}
+								envCounter--;
+								break;
+							case stateRelease:
+								if (expPeriod != 1)
+								{
+									delay = false;
+									return;
+								}
+								envCounter--;
+								break;
+						}
+						envCounter &= 0xFF;
+						UpdateExpCounter();
+					}
+				}
+			}
 
-            public void HardReset()
-            {
-                attack = 0;
-                decay = 0;
-                delay = true;
-                envCounter = 0;
-                expCounter = 0;
-                expPeriod = expPeriodTable[0];
-                freeze = false;
-                gate = false;
-                lfsr = 0x7FFF;
-                rate = adsrTable[release];
-                release = 0;
-                state = stateRelease;
-                sustain = 0;
-            }
+			public void HardReset()
+			{
+				attack = 0;
+				decay = 0;
+				delay = true;
+				envCounter = 0;
+				expCounter = 0;
+				expPeriod = expPeriodTable[0];
+				freeze = false;
+				gate = false;
+				lfsr = 0x7FFF;
+				rate = adsrTable[release];
+				release = 0;
+				state = stateRelease;
+				sustain = 0;
+			}
 
-            private void UpdateExpCounter()
-            {
+			private void UpdateExpCounter()
+			{
 
-                {
-                    for (int i = 0; i < 7; i++)
-                    {
-                        if (envCounter == expCounterTable[i])
-                            expPeriod = expPeriodTable[i];
-                    }
-                    if (envCounter == 0)
-                        freeze = true;
-                }
-            }
+				{
+					for (int i = 0; i < 7; i++)
+					{
+						if (envCounter == expCounterTable[i])
+							expPeriod = expPeriodTable[i];
+					}
+					if (envCounter == 0)
+						freeze = true;
+				}
+			}
 
-            // ------------------------------------
+			// ------------------------------------
 
-            public int Attack
-            {
-                get
-                {
-                    return attack;
-                }
-                set
-                {
-                    attack = (value & 0xF);
-                    if (state == stateAttack)
-                        rate = adsrTable[attack];
-                }
-            }
+			public int Attack
+			{
+				get
+				{
+					return attack;
+				}
+				set
+				{
+					attack = (value & 0xF);
+					if (state == stateAttack)
+						rate = adsrTable[attack];
+				}
+			}
 
-            public int Decay
-            {
-                get
-                {
-                    return decay;
-                }
-                set
-                {
-                    decay = (value & 0xF);
-                    if (state == stateDecay)
-                        rate = adsrTable[decay];
-                }
-            }
+			public int Decay
+			{
+				get
+				{
+					return decay;
+				}
+				set
+				{
+					decay = (value & 0xF);
+					if (state == stateDecay)
+						rate = adsrTable[decay];
+				}
+			}
 
-            public bool Gate
-            {
-                get
-                {
-                    return gate;
-                }
-                set
-                {
-                    bool nextGate = value;
-                    if (nextGate && !gate)
-                    {
-                        state = stateAttack;
-                        rate = adsrTable[attack];
-                        delay = true;
-                        freeze = false;
-                    }
-                    else if (!nextGate && gate)
-                    {
-                        state = stateRelease;
-                        rate = adsrTable[release];
-                    }
-                    gate = nextGate;
-                }
-            }
+			public bool Gate
+			{
+				get
+				{
+					return gate;
+				}
+				set
+				{
+					bool nextGate = value;
+					if (nextGate && !gate)
+					{
+						state = stateAttack;
+						rate = adsrTable[attack];
+						delay = true;
+						freeze = false;
+					}
+					else if (!nextGate && gate)
+					{
+						state = stateRelease;
+						rate = adsrTable[release];
+					}
+					gate = nextGate;
+				}
+			}
 
-            public int Level
-            {
-                get
-                {
-                    return envCounter;
-                }
-            }
+			public int Level
+			{
+				get
+				{
+					return envCounter;
+				}
+			}
 
-            public int Release
-            {
-                get
-                {
-                    return release;
-                }
-                set
-                {
-                    release = (value & 0xF);
-                    if (state == stateRelease)
-                        rate = adsrTable[release];
-                }
-            }
+			public int Release
+			{
+				get
+				{
+					return release;
+				}
+				set
+				{
+					release = (value & 0xF);
+					if (state == stateRelease)
+						rate = adsrTable[release];
+				}
+			}
 
-            public int Sustain
-            {
-                get
-                {
-                    return sustain;
-                }
-                set
-                {
-                    sustain = (value & 0xF);
-                }
-            }
+			public int Sustain
+			{
+				get
+				{
+					return sustain;
+				}
+				set
+				{
+					sustain = (value & 0xF);
+				}
+			}
 
-            // ------------------------------------
+			// ------------------------------------
 
-            public void SyncState(Serializer ser)
-            {
-                SaveState.SyncObject(ser, this);
-            }
+			public void SyncState(Serializer ser)
+			{
+				SaveState.SyncObject(ser, this);
+			}
 
-            // ------------------------------------
-        }
-    }
+			// ------------------------------------
+		}
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.Voice.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.Voice.cs
index 6e87c95ecf..8436b1ae3f 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.Voice.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.Voice.cs
@@ -3,342 +3,344 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
-    sealed public partial class Sid
-    {
-        sealed class Voice
-        {
-            int accBits;
-            int accNext;
-            int accumulator;
-            bool controlTestPrev;
-            int controlWavePrev;
-            int delay;
-            int floatOutputTTL;
-            int frequency;
-            bool msbRising;
-            int noise;
-            int noNoise;
-            int noNoiseOrNoise;
-            int noPulse;
-            int output;
-            int pulse;
-            int pulseWidth;
-            bool ringMod;
-            int ringMsbMask;
-            int shiftRegister;
-            int shiftRegisterReset;
-            bool sync;
-            bool test;
-            int[] wave;
-            int waveform;
-            int waveformIndex;
-            int[][] waveTable;
+	sealed public partial class Sid
+	{
+		sealed class Voice
+		{
+			int accBits;
+			int accNext;
+			int accumulator;
+			bool controlTestPrev;
+			int controlWavePrev;
+			int delay;
+			int floatOutputTTL;
+			int frequency;
+			bool msbRising;
+			int noise;
+			int noNoise;
+			int noNoiseOrNoise;
+			int noPulse;
+			int output;
+			int pulse;
+			int pulseWidth;
+			bool ringMod;
+			int ringMsbMask;
+			int shiftRegister;
+			int shiftRegisterReset;
+			bool sync;
+			bool test;
+			int[] wave;
+			int waveform;
+			int waveformIndex;
+			int[][] waveTable;
 
-            public Voice(int[][] newWaveTable)
-            {
-                waveTable = newWaveTable;
-                HardReset();
-            }
+			public Voice(int[][] newWaveTable)
+			{
+				waveTable = newWaveTable;
+				HardReset();
+			}
 
-            public void HardReset()
-            {
-                accumulator = 0;
-                delay = 0;
-                floatOutputTTL = 0;
-                frequency = 0;
-                msbRising = false;
-                noNoise = 0xFFF;
-                noPulse = 0xFFF;
-                output = 0x000;
-                pulse = 0xFFF;
-                pulseWidth = 0;
-                ringMsbMask = 0;
-                sync = false;
-                test = false;
-                wave = waveTable[0];
-                waveform = 0;
+			public void HardReset()
+			{
+				accumulator = 0;
+				delay = 0;
+				floatOutputTTL = 0;
+				frequency = 0;
+				msbRising = false;
+				noNoise = 0xFFF;
+				noPulse = 0xFFF;
+				output = 0x000;
+				pulse = 0xFFF;
+				pulseWidth = 0;
+				ringMsbMask = 0;
+				sync = false;
+				test = false;
+				wave = waveTable[0];
+				waveform = 0;
 
-                ResetShiftReg();
-            }
+				ResetShiftReg();
+			}
 
-            public void ExecutePhase2()
-            {
+			public void ExecutePhase2()
+			{
 
-                {
-                    if (test)
-                    {
-                        if (shiftRegisterReset != 0 && --shiftRegisterReset == 0)
-                        {
-                            ResetShiftReg();
-                        }
-                        pulse = 0xFFF;
-                    }
-                    else
-                    {
-                        accNext = (accumulator + frequency) & 0xFFFFFF;
-                        accBits = ~accumulator & accNext;
-                        accumulator = accNext;
-                        msbRising = ((accBits & 0x800000) != 0);
+				{
+					if (test)
+					{
+						if (shiftRegisterReset != 0 && --shiftRegisterReset == 0)
+						{
+							ResetShiftReg();
+						}
+						pulse = 0xFFF;
+					}
+					else
+					{
+						accNext = (accumulator + frequency) & 0xFFFFFF;
+						accBits = ~accumulator & accNext;
+						accumulator = accNext;
+						msbRising = ((accBits & 0x800000) != 0);
 
-                        if ((accBits & 0x080000) != 0)
-                            delay = 2;
-                        else if (delay != 0 && --delay == 0)
-                            ClockShiftReg();
-                    }
-                }
-            }
+						if ((accBits & 0x080000) != 0)
+							delay = 2;
+						else if (delay != 0 && --delay == 0)
+							ClockShiftReg();
+					}
+				}
+			}
 
-            // ------------------------------------
+			// ------------------------------------
 
-            private void ClockShiftReg()
-            {
+			private void ClockShiftReg()
+			{
 
-                {
-                    shiftRegister = ((shiftRegister << 1) |
-                        (((shiftRegister >> 22) ^ (shiftRegister >> 17)) & 0x1)
-                        ) & 0x7FFFFF;
-                    SetNoise();
-                }
-            }
+				{
+					shiftRegister = ((shiftRegister << 1) |
+						(((shiftRegister >> 22) ^ (shiftRegister >> 17)) & 0x1)
+						) & 0x7FFFFF;
+					SetNoise();
+				}
+			}
 
-            private void ResetShiftReg()
-            {
+			private void ResetShiftReg()
+			{
 
-                {
-                    shiftRegister = 0x7FFFFF;
-                    shiftRegisterReset = 0;
-                    SetNoise();
-                }
-            }
+				{
+					shiftRegister = 0x7FFFFF;
+					shiftRegisterReset = 0;
+					SetNoise();
+				}
+			}
 
-            private void SetNoise()
-            {
+			private void SetNoise()
+			{
 
-                {
-                    noise =
-                        ((shiftRegister & 0x100000) >> 9) |
-                        ((shiftRegister & 0x040000) >> 8) |
-                        ((shiftRegister & 0x004000) >> 5) |
-                        ((shiftRegister & 0x000800) >> 3) |
-                        ((shiftRegister & 0x000200) >> 2) |
-                        ((shiftRegister & 0x000020) << 1) |
-                        ((shiftRegister & 0x000004) << 3) |
-                        ((shiftRegister & 0x000001) << 4);
-                    noNoiseOrNoise = noNoise | noise;
-                }
-            }
+				{
+					noise =
+						((shiftRegister & 0x100000) >> 9) |
+						((shiftRegister & 0x040000) >> 8) |
+						((shiftRegister & 0x004000) >> 5) |
+						((shiftRegister & 0x000800) >> 3) |
+						((shiftRegister & 0x000200) >> 2) |
+						((shiftRegister & 0x000020) << 1) |
+						((shiftRegister & 0x000004) << 3) |
+						((shiftRegister & 0x000001) << 4);
+					noNoiseOrNoise = noNoise | noise;
+				}
+			}
 
-            private void WriteShiftReg()
-            {
+			private void WriteShiftReg()
+			{
 
-                {
-                    output &=
-                        0xBB5DA |
-                        ((output & 0x800) << 9) |
-                        ((output & 0x400) << 8) |
-                        ((output & 0x200) << 5) |
-                        ((output & 0x100) << 3) |
-                        ((output & 0x040) >> 1) |
-                        ((output & 0x020) >> 3) |
-                        ((output & 0x010) >> 4);
-                    noise &= output;
-                    noNoiseOrNoise = noNoise | noise;
-                }
-            }
+				{
+					output &=
+						0xBB5DA |
+						((output & 0x800) << 9) |
+						((output & 0x400) << 8) |
+						((output & 0x200) << 5) |
+						((output & 0x100) << 3) |
+						((output & 0x040) >> 1) |
+						((output & 0x020) >> 3) |
+						((output & 0x010) >> 4);
+					noise &= output;
+					noNoiseOrNoise = noNoise | noise;
+				}
+			}
 
-            // ------------------------------------
+			// ------------------------------------
 
-            public int Control
-            {
-                set
-                {
-                    controlWavePrev = waveform;
-                    controlTestPrev = test;
+			public int Control
+			{
+				set
+				{
+					controlWavePrev = waveform;
+					controlTestPrev = test;
 
-                    sync = ((value & 0x02) != 0);
-                    ringMod = ((value & 0x04) != 0);
-                    test = ((value & 0x08) != 0);
-                    waveform = (value >> 4) & 0x0F;
-                    wave = waveTable[waveform & 0x07];
-                    ringMsbMask = ((~value >> 5) & (value >> 2) & 0x1) << 23;
-                    noNoise = ((waveform & 0x8) != 0) ? 0x000 : 0xFFF;
-                    noNoiseOrNoise = noNoise | noise;
-                    noPulse = ((waveform & 0x4) != 0) ? 0x000 : 0xFFF;
+					sync = ((value & 0x02) != 0);
+					ringMod = ((value & 0x04) != 0);
+					test = ((value & 0x08) != 0);
+					waveform = (value >> 4) & 0x0F;
+					wave = waveTable[waveform & 0x07];
+					ringMsbMask = ((~value >> 5) & (value >> 2) & 0x1) << 23;
+					noNoise = ((waveform & 0x8) != 0) ? 0x000 : 0xFFF;
+					noNoiseOrNoise = noNoise | noise;
+					noPulse = ((waveform & 0x4) != 0) ? 0x000 : 0xFFF;
 
-                    if (!controlTestPrev && test)
-                    {
-                        accumulator = 0;
-                        delay = 0;
-                        shiftRegisterReset = 0x8000;
-                    }
-                    else if (controlTestPrev && !test)
-                    {
-                        shiftRegister = ((shiftRegister << 1) |
-                            ((~shiftRegister >> 17) & 0x1)
-                            ) & 0x7FFFFF;
-                        SetNoise();
-                    }
+					if (!controlTestPrev && test)
+					{
+						accumulator = 0;
+						delay = 0;
+						shiftRegisterReset = 0x8000;
+					}
+					else if (controlTestPrev && !test)
+					{
+						shiftRegister = ((shiftRegister << 1) |
+							((~shiftRegister >> 17) & 0x1)
+							) & 0x7FFFFF;
+						SetNoise();
+					}
 
-                    if (waveform == 0 && controlWavePrev != 0)
-                        floatOutputTTL = 0x28000;
-                }
-            }
+					if (waveform == 0 && controlWavePrev != 0)
+						floatOutputTTL = 0x28000;
+				}
+			}
 
-            public int Frequency
-            {
-                get
-                {
-                    return frequency;
-                }
-                set
-                {
-                    frequency = value;
-                }
-            }
+			public int Frequency
+			{
+				get
+				{
+					return frequency;
+				}
+				set
+				{
+					frequency = value;
+				}
+			}
 
-            public int FrequencyLo
-            {
-                get
-                {
-                    return (frequency & 0xFF);
-                }
-                set
-                {
-                    frequency &= 0xFF00;
-                    frequency |= value & 0x00FF;
-                }
-            }
+			public int FrequencyLo
+			{
+				get
+				{
+					return (frequency & 0xFF);
+				}
+				set
+				{
+					frequency &= 0xFF00;
+					frequency |= value & 0x00FF;
+				}
+			}
 
-            public int FrequencyHi
-            {
-                get
-                {
-                    return (frequency >> 8);
-                }
-                set
-                {
-                    frequency &= 0x00FF;
-                    frequency |= (value & 0x00FF) << 8;
-                }
-            }
+			public int FrequencyHi
+			{
+				get
+				{
+					return (frequency >> 8);
+				}
+				set
+				{
+					frequency &= 0x00FF;
+					frequency |= (value & 0x00FF) << 8;
+				}
+			}
 
-            public int Oscillator
-            {
-                get
-                {
-                    return output;
-                }
-            }
+			public int Oscillator
+			{
+				get
+				{
+					return output;
+				}
+			}
 
-            public int Output(Voice ringModSource)
-            {
+			public int Output(Voice ringModSource)
+			{
 
-                {
-                    if (waveform != 0)
-                    {
-                        waveformIndex = (accumulator ^ (ringModSource.accumulator & ringMsbMask)) >> 12;
-                        output = wave[waveformIndex] & (noPulse | pulse) & noNoiseOrNoise;
-                        if (waveform > 8)
-                            WriteShiftReg();
-                    }
-                    else
-                    {
-                        if (floatOutputTTL != 0 && --floatOutputTTL == 0)
-                            output = 0x000;
-                    }
-                    pulse = ((accumulator >> 12) >= pulseWidth) ? 0xFFF : 0x000;
-                    return output;
-                }
-            }
+				{
+					if (waveform != 0)
+					{
+						waveformIndex = (accumulator ^ (ringModSource.accumulator & ringMsbMask)) >> 12;
+						output = wave[waveformIndex] & (noPulse | pulse) & noNoiseOrNoise;
+						if (waveform > 8)
+							WriteShiftReg();
+					}
+					else
+					{
+						if (floatOutputTTL != 0 && --floatOutputTTL == 0)
+							output = 0x000;
+					}
+					pulse = ((accumulator >> 12) >= pulseWidth) ? 0xFFF : 0x000;
+					return output;
+				}
+			}
 
-            public int PulseWidth
-            {
-                get
-                {
-                    return pulseWidth;
-                }
-                set
-                {
-                    pulseWidth = value;
-                }
-            }
+			public int PulseWidth
+			{
+				get
+				{
+					return pulseWidth;
+				}
+				set
+				{
+					pulseWidth = value;
+				}
+			}
 
-            public int PulseWidthLo
-            {
-                get
-                {
-                    return (pulseWidth & 0xFF);
-                }
-                set
-                {
-                    pulseWidth &= 0x0F00;
-                    pulseWidth |= value & 0x00FF;
-                }
-            }
+			public int PulseWidthLo
+			{
+				get
+				{
+					return (pulseWidth & 0xFF);
+				}
+				set
+				{
+					pulseWidth &= 0x0F00;
+					pulseWidth |= value & 0x00FF;
+				}
+			}
 
-            public int PulseWidthHi
-            {
-                get
-                {
-                    return (pulseWidth >> 8);
-                }
-                set
-                {
-                    pulseWidth &= 0x00FF;
-                    pulseWidth |= (value & 0x000F) << 8;
-                }
-            }
+			public int PulseWidthHi
+			{
+				get
+				{
+					return (pulseWidth >> 8);
+				}
+				set
+				{
+					pulseWidth &= 0x00FF;
+					pulseWidth |= (value & 0x000F) << 8;
+				}
+			}
 
-            public bool RingMod
-            {
-                get
-                {
-                    return ringMod;
-                }
-            }
+			public bool RingMod
+			{
+				get
+				{
+					return ringMod;
+				}
+			}
 
-            public bool Sync
-            {
-                get
-                {
-                    return sync;
-                }
-            }
+			public bool Sync
+			{
+				get
+				{
+					return sync;
+				}
+			}
 
-            public void Synchronize(Voice target, Voice source)
-            {
-                if (msbRising && target.sync && !(sync && source.msbRising))
-                    target.accumulator = 0;
-            }
+			public void Synchronize(Voice target, Voice source)
+			{
+				if (msbRising && target.sync && !(sync && source.msbRising))
+					target.accumulator = 0;
+			}
 
-            public bool Test
-            {
-                get
-                {
-                    return test;
-                }
-            }
+			public bool Test
+			{
+				get
+				{
+					return test;
+				}
+			}
 
-            public int Waveform
-            {
-                get
-                {
-                    return waveform;
-                }
-            }
+			public int Waveform
+			{
+				get
+				{
+					return waveform;
+				}
+			}
 
-            // ------------------------------------
+			// ------------------------------------
 
-            public void SyncState(Serializer ser)
-            {
-                SaveState.SyncObject(ser, this);
+			public void SyncState(Serializer ser)
+			{
+				SaveState.SyncObject(ser, this);
 
-                if (ser.IsReader)
-                    wave = waveTable[waveform];
-            }
-        }
+				if (ser.IsReader)
+					wave = waveTable[waveform];
+			}
+		}
 
-    }
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.cs
index 5ec2a5a6b5..f184498155 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Sid.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 #pragma warning disable 649 //adelikat: Disable dumb warnings until this file is complete
 #pragma warning disable 169 //adelikat: Disable dumb warnings until this file is complete
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/UserPort.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/UserPort.cs
index bb9c204be4..7039b28269 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/UserPort.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/UserPort.cs
@@ -1,72 +1,73 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
 	public class UserPort
 	{
-        public Func<bool> ReadCounter1;
-        public Func<bool> ReadCounter2;
-        public Func<bool> ReadHandshake;
-        public Func<bool> ReadSerial1;
-        public Func<bool> ReadSerial2;
+		public Func<bool> ReadCounter1;
+		public Func<bool> ReadCounter2;
+		public Func<bool> ReadHandshake;
+		public Func<bool> ReadSerial1;
+		public Func<bool> ReadSerial2;
 
 		public UserPort()
 		{
 		}
 
-        virtual public void HardReset()
+		virtual public void HardReset()
 		{
 			// note: this will not disconnect any attached media
 		}
 
-        virtual public bool ReadAtn()
-        {
-            return true;
-        }
+		virtual public bool ReadAtn()
+		{
+			return true;
+		}
 
-        virtual public bool ReadCounter1Buffer()
-        {
-            return true;
-        }
+		virtual public bool ReadCounter1Buffer()
+		{
+			return true;
+		}
 
-        virtual public bool ReadCounter2Buffer()
-        {
-            return true;
-        }
+		virtual public bool ReadCounter2Buffer()
+		{
+			return true;
+		}
 
-        virtual public byte ReadData()
-        {
-            return 0xFF;
-        }
+		virtual public byte ReadData()
+		{
+			return 0xFF;
+		}
 
-        virtual public bool ReadFlag2()
-        {
-            return true;
-        }
+		virtual public bool ReadFlag2()
+		{
+			return true;
+		}
 
-        virtual public bool ReadPA2()
-        {
-            return true;
-        }
+		virtual public bool ReadPA2()
+		{
+			return true;
+		}
 
-        virtual public bool ReadReset()
-        {
-            return true;
-        }
+		virtual public bool ReadReset()
+		{
+			return true;
+		}
 
-        virtual public bool ReadSerial1Buffer()
-        {
-            return true;
-        }
+		virtual public bool ReadSerial1Buffer()
+		{
+			return true;
+		}
 
-        virtual public bool ReadSerial2Buffer()
-        {
-            return true;
-        }
+		virtual public bool ReadSerial2Buffer()
+		{
+			return true;
+		}
 
-        public void SyncState(Serializer ser)
-        {
-            SaveState.SyncObject(ser, this);
-        }
-    }
+		public void SyncState(Serializer ser)
+		{
+			SaveState.SyncObject(ser, this);
+		}
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.SpriteGenerator.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.SpriteGenerator.cs
index 03708ea3ff..f0f69348fb 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.SpriteGenerator.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.SpriteGenerator.cs
@@ -3,61 +3,63 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
-    sealed public partial class Vic
-    {
-        sealed class SpriteGenerator
-        {
-            public bool collideData;
-            public bool collideSprite;
-            public int color;
-            public bool display;
-            public bool dma;
-            public bool enable;
-            public int mc;
-            public int mcbase;
-            public bool multicolor;
-            public bool multicolorCrunch;
-            public int pointer;
-            public bool priority;
-            public bool shiftEnable;
-            public int sr;
-            public int x;
-            public bool xCrunch;
-            public bool xExpand;
-            public int y;
-            public bool yCrunch;
-            public bool yExpand;
+	sealed public partial class Vic
+	{
+		sealed class SpriteGenerator
+		{
+			public bool collideData;
+			public bool collideSprite;
+			public int color;
+			public bool display;
+			public bool dma;
+			public bool enable;
+			public int mc;
+			public int mcbase;
+			public bool multicolor;
+			public bool multicolorCrunch;
+			public int pointer;
+			public bool priority;
+			public bool shiftEnable;
+			public int sr;
+			public int x;
+			public bool xCrunch;
+			public bool xExpand;
+			public int y;
+			public bool yCrunch;
+			public bool yExpand;
 
-            public void HardReset()
-            {
-                collideData = false;
-                collideSprite = false;
-                color = 0;
-                display = false;
-                dma = false;
-                enable = false;
-                mc = 0;
-                mcbase = 0;
-                multicolor = false;
-                multicolorCrunch = false;
-                pointer = 0;
-                priority = false;
-                shiftEnable = false;
-                sr = 0;
-                x = 0;
-                xCrunch = false;
-                xExpand = false;
-                y = 0;
-                yCrunch = false;
-                yExpand = false;
-            }
+			public void HardReset()
+			{
+				collideData = false;
+				collideSprite = false;
+				color = 0;
+				display = false;
+				dma = false;
+				enable = false;
+				mc = 0;
+				mcbase = 0;
+				multicolor = false;
+				multicolorCrunch = false;
+				pointer = 0;
+				priority = false;
+				shiftEnable = false;
+				sr = 0;
+				x = 0;
+				xCrunch = false;
+				xExpand = false;
+				y = 0;
+				yCrunch = false;
+				yExpand = false;
+			}
 
-            public void SyncState(Serializer ser)
-            {
-                SaveState.SyncObject(ser, this);
-            }
-        }
-    }
+			public void SyncState(Serializer ser)
+			{
+				SaveState.SyncObject(ser, this);
+			}
+		}
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.State.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.State.cs
index 0e0a3578c4..06ec716cab 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.State.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.State.cs
@@ -4,184 +4,186 @@ using System.Linq;
 using System.Reflection;
 using System.Text;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
-    sealed public partial class Vic
-    {
-        int backgroundColor0;
-        int backgroundColor1;
-        int backgroundColor2;
-        int backgroundColor3;
-        int baCount;
-        bool badline;
-        bool badlineEnable;
-        int bitmapColumn;
-        bool bitmapMode;
-        int borderB;
-        bool borderCheckLEnable;
-        bool borderCheckREnable;
-        int borderColor;
-        int borderL;
-        bool borderOnMain;
-        bool borderOnVertical;
-        int borderR;
-        int borderT;
-        int[] bufferC;
-        int[] bufferG;
-        int cycle;
-        int cycleIndex;
-        bool columnSelect;
-        int dataC;
-        int dataG;
-        bool displayEnable;
-        int displayC;
-        bool enableIntLightPen;
-        bool enableIntRaster;
-        bool enableIntSpriteCollision;
-        bool enableIntSpriteDataCollision;
-        bool extraColorMode;
-        bool hblank;
-        bool idle;
-        bool intLightPen;
-        bool intRaster;
-        bool intSpriteCollision;
-        bool intSpriteDataCollision;
-        int hblankEnd;
-        int hblankStart;
-        bool hblankCheckEnableL;
-        bool hblankCheckEnableR;
-        int lastRasterLine;
-        int lightPenX;
-        int lightPenY;
-        bool multicolorMode;
-        bool pinAEC = true;
-        bool pinBA = true;
-        bool pinIRQ = true;
-        int pointerCB;
-        int pointerVM;
-        int rasterInterruptLine;
-        int rasterLine;
-        int rasterX;
-        bool rasterXHold;
-        int rc;
-        int refreshCounter;
-        bool renderEnabled;
-        bool rowSelect;
-        int spriteMulticolor0;
-        int spriteMulticolor1;
-        SpriteGenerator[] sprites;
-        int sr;
-        int srMask;
-        int srMask1;
-        int srMask2;
-        int srMask3;
-        int srMaskMC;
-        int srSpriteMask;
-        int srSpriteMask1;
-        int srSpriteMask2;
-        int srSpriteMask3;
-        int srSpriteMaskMC;
-        bool vblank;
-        int vblankEnd;
-        int vblankStart;
-        int vc;
-        int vcbase;
-        int vmli;
-        int xScroll;
-        int yScroll;
+	sealed public partial class Vic
+	{
+		int backgroundColor0;
+		int backgroundColor1;
+		int backgroundColor2;
+		int backgroundColor3;
+		int baCount;
+		bool badline;
+		bool badlineEnable;
+		int bitmapColumn;
+		bool bitmapMode;
+		int borderB;
+		bool borderCheckLEnable;
+		bool borderCheckREnable;
+		int borderColor;
+		int borderL;
+		bool borderOnMain;
+		bool borderOnVertical;
+		int borderR;
+		int borderT;
+		int[] bufferC;
+		int[] bufferG;
+		int cycle;
+		int cycleIndex;
+		bool columnSelect;
+		int dataC;
+		int dataG;
+		bool displayEnable;
+		int displayC;
+		bool enableIntLightPen;
+		bool enableIntRaster;
+		bool enableIntSpriteCollision;
+		bool enableIntSpriteDataCollision;
+		bool extraColorMode;
+		bool hblank;
+		bool idle;
+		bool intLightPen;
+		bool intRaster;
+		bool intSpriteCollision;
+		bool intSpriteDataCollision;
+		int hblankEnd;
+		int hblankStart;
+		bool hblankCheckEnableL;
+		bool hblankCheckEnableR;
+		int lastRasterLine;
+		int lightPenX;
+		int lightPenY;
+		bool multicolorMode;
+		bool pinAEC = true;
+		bool pinBA = true;
+		bool pinIRQ = true;
+		int pointerCB;
+		int pointerVM;
+		int rasterInterruptLine;
+		int rasterLine;
+		int rasterX;
+		bool rasterXHold;
+		int rc;
+		int refreshCounter;
+		bool renderEnabled;
+		bool rowSelect;
+		int spriteMulticolor0;
+		int spriteMulticolor1;
+		SpriteGenerator[] sprites;
+		int sr;
+		int srMask;
+		int srMask1;
+		int srMask2;
+		int srMask3;
+		int srMaskMC;
+		int srSpriteMask;
+		int srSpriteMask1;
+		int srSpriteMask2;
+		int srSpriteMask3;
+		int srSpriteMaskMC;
+		bool vblank;
+		int vblankEnd;
+		int vblankStart;
+		int vc;
+		int vcbase;
+		int vmli;
+		int xScroll;
+		int yScroll;
 
-        public void HardReset()
-        {
-            // *** SHIFT REGISTER BITMASKS ***
-            srMask1 = 0x20000;
-            srMask2 = srMask1 << 1;
-            srMask3 = srMask1 | srMask2;
-            srMask = srMask2;
-            srMaskMC = srMask3;
-            srSpriteMask1 = 0x400000;
-            srSpriteMask2 = srSpriteMask1 << 1;
-            srSpriteMask3 = srSpriteMask1 | srSpriteMask2;
-            srSpriteMask = srSpriteMask2;
-            srSpriteMaskMC = srSpriteMask3;
+		public void HardReset()
+		{
+			// *** SHIFT REGISTER BITMASKS ***
+			srMask1 = 0x20000;
+			srMask2 = srMask1 << 1;
+			srMask3 = srMask1 | srMask2;
+			srMask = srMask2;
+			srMaskMC = srMask3;
+			srSpriteMask1 = 0x400000;
+			srSpriteMask2 = srSpriteMask1 << 1;
+			srSpriteMask3 = srSpriteMask1 | srSpriteMask2;
+			srSpriteMask = srSpriteMask2;
+			srSpriteMaskMC = srSpriteMask3;
 
-            pinAEC = true;
-            pinBA = true;
-            pinIRQ = true;
+			pinAEC = true;
+			pinBA = true;
+			pinIRQ = true;
 
-            bufOffset = 0;
+			bufOffset = 0;
 
-            backgroundColor0 = 0;
-            backgroundColor1 = 0;
-            backgroundColor2 = 0;
-            backgroundColor3 = 0;
-            baCount = baResetCounter;
-            badline = false;
-            badlineEnable = false;
-            bitmapMode = false;
-            borderCheckLEnable = false;
-            borderCheckREnable = false;
-            borderColor = 0;
-            borderOnMain = true;
-            borderOnVertical = true;
-            columnSelect = false;
-            displayEnable = false;
-            enableIntLightPen = false;
-            enableIntRaster = false;
-            enableIntSpriteCollision = false;
-            enableIntSpriteDataCollision = false;
-            extraColorMode = false;
-            hblank = true;
-            idle = true;
-            intLightPen = false;
-            intRaster = false;
-            intSpriteCollision = false;
-            intSpriteDataCollision = false;
-            lastRasterLine = 0;
-            lightPenX = 0;
-            lightPenY = 0;
-            multicolorMode = false;
-            pointerCB = 0;
-            pointerVM = 0;
-            rasterInterruptLine = 0;
-            rasterLine = 0;
-            rasterX = 0;
-            rc = 7;
-            refreshCounter = 0xFF;
-            rowSelect = false;
-            spriteMulticolor0 = 0;
-            spriteMulticolor1 = 0;
-            sr = 0;
-            vblank = true;
-            vc = 0;
-            vcbase = 0;
-            vmli = 0;
-            xScroll = 0;
-            yScroll = 0;
+			backgroundColor0 = 0;
+			backgroundColor1 = 0;
+			backgroundColor2 = 0;
+			backgroundColor3 = 0;
+			baCount = baResetCounter;
+			badline = false;
+			badlineEnable = false;
+			bitmapMode = false;
+			borderCheckLEnable = false;
+			borderCheckREnable = false;
+			borderColor = 0;
+			borderOnMain = true;
+			borderOnVertical = true;
+			columnSelect = false;
+			displayEnable = false;
+			enableIntLightPen = false;
+			enableIntRaster = false;
+			enableIntSpriteCollision = false;
+			enableIntSpriteDataCollision = false;
+			extraColorMode = false;
+			hblank = true;
+			idle = true;
+			intLightPen = false;
+			intRaster = false;
+			intSpriteCollision = false;
+			intSpriteDataCollision = false;
+			lastRasterLine = 0;
+			lightPenX = 0;
+			lightPenY = 0;
+			multicolorMode = false;
+			pointerCB = 0;
+			pointerVM = 0;
+			rasterInterruptLine = 0;
+			rasterLine = 0;
+			rasterX = 0;
+			rc = 7;
+			refreshCounter = 0xFF;
+			rowSelect = false;
+			spriteMulticolor0 = 0;
+			spriteMulticolor1 = 0;
+			sr = 0;
+			vblank = true;
+			vc = 0;
+			vcbase = 0;
+			vmli = 0;
+			xScroll = 0;
+			yScroll = 0;
 
-            // reset sprites
-            for (int i = 0; i < 8; i++)
-                sprites[i].HardReset();
+			// reset sprites
+			for (int i = 0; i < 8; i++)
+				sprites[i].HardReset();
 
-            // clear C buffer
-            for (int i = 0; i < 40; i++)
-            {
-                bufferC[i] = 0;
-                bufferG[i] = 0;
-            }
+			// clear C buffer
+			for (int i = 0; i < 40; i++)
+			{
+				bufferC[i] = 0;
+				bufferG[i] = 0;
+			}
 
-            pixBuffer = new int[pixBufferSize];
-            UpdateBorder();
-        }
+			pixBuffer = new int[pixBufferSize];
+			UpdateBorder();
+		}
 
-        public void SyncState(Serializer ser)
-        {
-            SaveState.SyncObject(ser, this);
-            for (int i = 0; i < 8; i++)
-            {
-                ser.BeginSection("sprite" + i.ToString());
-                SaveState.SyncObject(ser, sprites[i]);
-                ser.EndSection();
-            }
-        }
-    }
+		public void SyncState(Serializer ser)
+		{
+			SaveState.SyncObject(ser, this);
+			for (int i = 0; i < 8; i++)
+			{
+				ser.BeginSection("sprite" + i.ToString());
+				SaveState.SyncObject(ser, sprites[i]);
+				ser.EndSection();
+			}
+		}
+	}
 }
diff --git a/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.VideoProvider.cs b/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.VideoProvider.cs
index 0d8c79e61b..e8022f305a 100644
--- a/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.VideoProvider.cs
+++ b/BizHawk.Emulation/Computers/Commodore64/MOS/Vic.VideoProvider.cs
@@ -1,17 +1,18 @@
 using System.Drawing;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Computers.Commodore64.MOS
 {
-    sealed public partial class Vic : IVideoProvider
+	sealed public partial class Vic : IVideoProvider
 	{
 		int[] buf;
 		int bufHeight;
 		int bufLength;
 		int bufOffset;
 		int bufWidth;
-        int pixBufferSize = 12;
-        int[] pixBuffer;
-        int pixBufferIndex;
+		int pixBufferSize = 12;
+		int[] pixBuffer;
+		int pixBufferIndex;
 
 		// palette
 		int[] palette =
@@ -56,7 +57,7 @@ namespace BizHawk.Emulation.Computers.Commodore64.MOS
 
 		public int VirtualWidth
 		{
-            get { return bufWidth; }
+			get { return bufWidth; }
 		}
 	}
 }
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Atari2600.Core.cs b/BizHawk.Emulation/Consoles/Atari/2600/Atari2600.Core.cs
index a76c2607d2..72f8aeb78a 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Atari2600.Core.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Atari2600.Core.cs
@@ -1,7 +1,9 @@
 using System;
+
 using BizHawk.Emulation.CPUs.M6502;
 using BizHawk.Emulation.Consoles.Atari;
 using BizHawk.Emulation.Consoles.Atari._2600;
+using BizHawk.Common;
 
 namespace BizHawk
 {
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Atari2600.cs b/BizHawk.Emulation/Consoles/Atari/2600/Atari2600.cs
index d0233bfcf5..f0590f753c 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Atari2600.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Atari2600.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 
+using BizHawk.Common;
+
 namespace BizHawk
 {
 	public partial class Atari2600 : IEmulator
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/M6532.cs b/BizHawk.Emulation/Consoles/Atari/2600/M6532.cs
index 7f68b023ad..7834435203 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/M6532.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/M6532.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari
 {
 	// Emulates the M6532 RIOT Chip
 	public class M6532
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m3E.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m3E.cs
index d07e14702c..fd81bf627c 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m3E.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m3E.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	3E (Boulderdash
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m3F.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m3F.cs
index 64657a78c7..520c5ae9b1 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m3F.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m3F.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	3F (Tigervision)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m4A50.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m4A50.cs
index 6dd97ba64e..ff82acbe87 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m4A50.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/m4A50.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	4A50 (no name)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mCV.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mCV.cs
index 0334af8d6c..3bb9271cc0 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mCV.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mCV.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	This was used by Commavid.  It allowed for both ROM and RAM on the cartridge,
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mDPC.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mDPC.cs
index 7f0638373d..6bda94d9e4 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mDPC.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mDPC.cs
@@ -1,4 +1,6 @@
-namespace BizHawk
+using BizHawk.Common;
+
+namespace BizHawk
 {
 	partial class Atari2600
 	{
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mE0.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mE0.cs
index 7dfef494bc..486ceb3b68 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mE0.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mE0.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	E0 (Parker Bros)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mE7.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mE7.cs
index 091e73f459..d4ad6088fd 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mE7.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mE7.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	E7 (M-Network)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mEF.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mEF.cs
index 272c049bee..f00bf49054 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mEF.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mEF.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	EF (no name?)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF0.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF0.cs
index 7d946ec79d..8898c17cf5 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF0.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF0.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	F0 (Megaboy)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF4.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF4.cs
index 2b23ab05f5..ab63dfe82e 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF4.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF4.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	F4 (Atari style 32K)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF6.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF6.cs
index 2477c23bc9..a76c65959c 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF6.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF6.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	F6 (Atari style 16K)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF8.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF8.cs
index ec9a526199..24c03cd2e0 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF8.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mF8.cs
@@ -1,4 +1,6 @@
-namespace BizHawk
+using BizHawk.Common;
+
+namespace BizHawk
 {
 	partial class Atari2600
 	{
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mFA.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mFA.cs
index dfc314ebec..71b63fe533 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mFA.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mFA.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	FA (RAM Plus)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mUA.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mUA.cs
index c1076e3c83..6ee4a66c81 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mUA.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mUA.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	UA (UA Ltd)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mX07.cs b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mX07.cs
index c3d43bc245..9abfebbeaf 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mX07.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/Mappers/mX07.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Atari._2600
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Atari._2600
 {
 	/*
 	X07 (Atariage)
diff --git a/BizHawk.Emulation/Consoles/Atari/2600/TIA.cs b/BizHawk.Emulation/Consoles/Atari/2600/TIA.cs
index 3bc8aa07e2..c67efcbd90 100644
--- a/BizHawk.Emulation/Consoles/Atari/2600/TIA.cs
+++ b/BizHawk.Emulation/Consoles/Atari/2600/TIA.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Consoles.Atari
 {
 	// Emulates the TIA
diff --git a/BizHawk.Emulation/Consoles/Atari/7800/Atari7800.cs b/BizHawk.Emulation/Consoles/Atari/7800/Atari7800.cs
index 50b7762d91..5287df40dd 100644
--- a/BizHawk.Emulation/Consoles/Atari/7800/Atari7800.cs
+++ b/BizHawk.Emulation/Consoles/Atari/7800/Atari7800.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+
+using BizHawk.Common;
 using EMU7800.Core;
 
 namespace BizHawk.Emulation
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/BisqAPU.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/BisqAPU.cs
index 5c5fc643de..7edd4133f7 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/BisqAPU.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/BisqAPU.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 
+using BizHawk.Common;
 using BizHawk.Emulation.Sound;
 
 //http://wiki.nesdev.com/w/index.php/APU_Mixer_Emulation
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/BoardSystem.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/BoardSystem.cs
index 312f5a15ea..1f921c9334 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/BoardSystem.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/BoardSystem.cs
@@ -3,6 +3,8 @@ using System.Xml;
 using System.IO;
 using System.Collections.Generic;
 
+using BizHawk.Common;
+
 //TODO - consider bytebuffer for mirroring
 //TODO - could stringpool the bootgod DB for a pedantic optimization
 
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AVE-NINA.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AVE-NINA.cs
index 37e8391261..d41e132146 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AVE-NINA.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AVE-NINA.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//AKA half of mapper 034 (the other half is BxROM which is entirely different..)
 	public sealed class AVE_NINA_001 : NES.NESBoardBase
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AxROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AxROM.cs
index 4a4c5a7530..f9bda4bba3 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AxROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AxROM.cs
@@ -1,3 +1,5 @@
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//generally mapper7
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BANDAI_74_161_02_74.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BANDAI_74_161_02_74.cs
index 0739a63459..c0fd174d10 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BANDAI_74_161_02_74.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BANDAI_74_161_02_74.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class BANDAI_74_161_02_74 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BANDAI_74_161_161_32.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BANDAI_74_161_161_32.cs
index ee31f3c96e..b40be8d22c 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BANDAI_74_161_161_32.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BANDAI_74_161_161_32.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class BANDAI_74_161_161_32 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BxROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BxROM.cs
index 3665637274..ee5067cdd6 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BxROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/BxROM.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//AKA half of mapper 034 (the other half is AVE_NINA_001 which is entirely different..)
 	public sealed class BxROM : NES.NESBoardBase
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CNROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CNROM.cs
index 81bb106ac9..4db70441b6 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CNROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CNROM.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CPROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CPROM.cs
index 9e719e6d6e..33a4950ddc 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CPROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CPROM.cs
@@ -1,6 +1,7 @@
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
-
 	public sealed class CPROM : NES.NESBoardBase
 	{
 		//generally mapper 13
@@ -61,7 +62,5 @@ namespace BizHawk.Emulation.Consoles.Nintendo
 			base.SyncState(ser);
 			ser.Sync("chr",ref chr);
 		}
-
-
 	}
 }
\ No newline at end of file
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/ExROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/ExROM.cs
index c521b3484d..dbd06530c3 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/ExROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/ExROM.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 //simplifications/approximations:
 //* "Note that no commercial games rely on this mirroring -- therefore you can take the easy way out and simply give all MMC5 games 64k PRG-RAM."
@@ -12,7 +13,6 @@
 //TODO - tweak nametable / chr viewer to be more useful
 
 //FUTURE - we may need to split this into a separate MMC5 class. but for now it is just a pain.
-
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	[NES.INESBoardImplPriority]
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/GxROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/GxROM.cs
index e63d44a7fd..8399129f97 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/GxROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/GxROM.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IC_74x377.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IC_74x377.cs
index 5d1ca2d221..1425a08557 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IC_74x377.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IC_74x377.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IREM-74_161_161_21_138.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IREM-74_161_161_21_138.cs
index 25853bdcbf..588ead2b03 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IREM-74_161_161_21_138.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IREM-74_161_161_21_138.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//Mapper 77
 	//Napoleon Senki
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IREM_TAM_S1.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IREM_TAM_S1.cs
index f67768d2ea..0015195b12 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IREM_TAM_S1.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IREM_TAM_S1.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//iNES Mapper 97
 	//Kaiketsu Yanchamaru (Kid Niki 1)
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Irem_G101.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Irem_G101.cs
index ac458e399b..2606545646 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Irem_G101.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Irem_G101.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//AKA mapper 032
 
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Irem_H3001.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Irem_H3001.cs
index 2cbdd0b30f..edb43283f3 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Irem_H3001.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Irem_H3001.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//AKA mapper 65
 
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_JF_13.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_JF_13.cs
index ad159fa744..c0aed21a9c 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_JF_13.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_JF_13.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//Mapper 86
 	
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_JF_17.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_JF_17.cs
index 9b4d1243e1..e9b201b6ef 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_JF_17.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_JF_17.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//iNES Mapper 72
 	//Example Games:
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_SS8806.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_SS8806.cs
index 5ff17758f0..cc37db8850 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_SS8806.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/JALECO_SS8806.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class JALECO_SS8806 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Jaleco-JF_11_14.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Jaleco-JF_11_14.cs
index b29d268920..91995c1cb5 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Jaleco-JF_11_14.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Jaleco-JF_11_14.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	/*
 	 * Life Span: October 1986 - April 1987
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper012.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper012.cs
index c73f41878d..bbb7fa3c98 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper012.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper012.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper012 : MMC3Board_Base
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper037.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper037.cs
index 9c976599bd..d76143f208 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper037.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper037.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// mmc3 multi, PAL, "Super Mario Bros. / Tetris / Nintendo World Cup"
 	public sealed class Mapper037 : MMC3Board_Base
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper044.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper044.cs
index 3a4bc70cf5..087e5abcdb 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper044.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper044.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//http://wiki.nesdev.com/w/index.php/INES_Mapper_044
 	public class Mapper044 : MMC3Board_Base
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper165.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper165.cs
index bb4691a960..bf1d9b8f2f 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper165.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper165.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// Fire Emblem (Ch)
 	// mmc3 with mmc2-style chr swapping
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper189.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper189.cs
index 034ae3d942..bf9c496409 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper189.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper189.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper189 : MMC3Board_Base
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper205.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper205.cs
index fe11d96510..ed20f8f323 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper205.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/Mapper205.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper205 : MMC3Board_Base
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/NES-QJ.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/NES-QJ.cs
index 924b517cf5..7deb4e329b 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/NES-QJ.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/NES-QJ.cs
@@ -1,3 +1,5 @@
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class NES_QJ : MMC3Board_Base
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/TxROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/TxROM.cs
index 4441d2d9e4..aa7487386a 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/TxROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/MMC3_family/TxROM.cs
@@ -1,6 +1,8 @@
 //http://wiki.nesdev.com/w/index.php/TxROM
 //read some background info on namco 108 and DxROM boards here
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	[NES.INESBoardImplPriority]
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper028.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper028.cs
index 2aa1aaa892..8600995e4e 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper028.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper028.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// http://wiki.nesdev.com/w/index.php/User:Tepples/Multi-discrete_mapper
 	public sealed class Mapper028 : NES.NESBoardBase
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper036.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper036.cs
index 85b8d031ca..2e74553cd5 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper036.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper036.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// mapper036
 	// Strike Wolf (MGC-014) [!].nes
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper038.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper038.cs
index 37fb31645a..61be5b0605 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper038.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper038.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// Crime Busters (Brazil) (Unl)
 	public sealed class Mapper038 : NES.NESBoardBase
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper040.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper040.cs
index e103687321..000c29907e 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper040.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper040.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// smb2j (us pirate)
 	public sealed class Mapper040 : NES.NESBoardBase
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper041.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper041.cs
index ca415a1f2e..62e069159b 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper041.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper041.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// caltron 6 in 1
 	public sealed class Mapper041 : NES.NESBoardBase
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper042.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper042.cs
index 3247c1af2f..6088e12ff9 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper042.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper042.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper046.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper046.cs
index 273483a910..495e0fb49e 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper046.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper046.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper046 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper091.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper091.cs
index c8f0dfb485..e643f71f1c 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper091.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper091.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper91 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper101.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper101.cs
index f9a2ec5800..4a399c3d9d 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper101.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper101.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//Urusei Yatsura - Lum no Wedding Bell (J)
 	public sealed class Mapper101 : NES.NESBoardBase
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper103.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper103.cs
index d74acd223d..700a6eb4a5 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper103.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper103.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// Doki Doki Panic (FDS port)
 	// "BTL 2708"
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper107.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper107.cs
index f92bd16f31..006e1a3570 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper107.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper107.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper107 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper108.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper108.cs
index df83322064..18c612c373 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper108.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper108.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// Meikyuu Jiin Dababa (FDS Conversion)
 	public sealed class Mapper108 : NES.NESBoardBase
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper120.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper120.cs
index 17134cf10a..29175b75fa 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper120.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper120.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper120 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper132.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper132.cs
index c74b602ee0..abbfe2364a 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper132.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper132.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// Creatom
 	// specs pulled from Nintendulator sources
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper156.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper156.cs
index 4cb1622f3c..ee0a701d86 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper156.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper156.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// behavior pulled from fceux:
 	/*
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper164.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper164.cs
index 9668aa850a..12d900aa98 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper164.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper164.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper164 : NES.NESBoardBase 
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper168.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper168.cs
index 99180f8d64..96121c8f12 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper168.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper168.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// RacerMate II
 	// 64KB PRGROM, 64KB CHRRAM(!), CHRRAM is battry backed (!!)
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper177.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper177.cs
index 11f5c13387..9cde48ad75 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper177.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper177.cs
@@ -1,10 +1,12 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// china
 	// behavior from fceux
 	public sealed class Mapper177 : NES.NESBoardBase
 	{
-		int prg;
+		private int prg;
 
 		public override bool Configure(NES.EDetectionOrigin origin)
 		{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper180.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper180.cs
index 6dbf5c5c27..bb6ffab6fe 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper180.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper180.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper180 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper193.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper193.cs
index 82421277e6..f55e3db9cd 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper193.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper193.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper193 : NES.NESBoardBase 
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper201.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper201.cs
index 82f839ee1b..153c14407d 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper201.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper201.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper201 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper203.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper203.cs
index 71304e2ec0..fc52acb690 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper203.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper203.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper203 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper240.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper240.cs
index 59cfd26f4a..dabb8e318c 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper240.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper240.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper241.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper241.cs
index b31cf76b19..07c2983f0f 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper241.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper241.cs
@@ -1,9 +1,11 @@
-//163 is for nanjing games
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper241 : NES.NESBoardBase
 	{
+		//163 is for nanjing games
+
 		//configuration
 		int prg_bank_mask_32k;
 
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper243.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper243.cs
index 683ca6a5df..5206c324aa 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper243.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper243.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper243 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper246.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper246.cs
index 7a31ce1cc6..90c84315b2 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper246.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper246.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper246 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper60.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper60.cs
index 6a6dba0d6d..446e4e0617 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper60.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Mapper60.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper60 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Mapper112.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Mapper112.cs
index ca34838bb2..13d65e2f31 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Mapper112.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Mapper112.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class Mapper112 : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Namco163Audio.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Namco163Audio.cs
index 88d106bee2..976512f669 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Namco163Audio.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Namco163Audio.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Namcot1xx.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Namcot1xx.cs
index f005fb1f69..0953901996 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Namcot1xx.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Namcot1xx/Namcot1xx.cs
@@ -4,6 +4,7 @@
 //but mostly http://wiki.nesdev.com/w/index.php/INES_Mapper_206
 
 using System;
+using BizHawk.Common;
 
 //TODO - prg is 4 bits, chr is 6 bits
 
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/NanJing.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/NanJing.cs
index d12d7609e6..288b06bea2 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/NanJing.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/NanJing.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class NanJing : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/NovelDiamond.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/NovelDiamond.cs
index b738ee7b07..786d8a4144 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/NovelDiamond.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/NovelDiamond.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	public sealed class NovelDiamond : NES.NESBoardBase
 	{
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SachenSimple.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SachenSimple.cs
index acaacddd64..97f861a6b0 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SachenSimple.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SachenSimple.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft1.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft1.cs
index d8845eebd5..378ecd23c8 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft1.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft1.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//AKA mapper 184
 	//Sunsoft-1 chips, EXCEPT for fantasy zone.
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft4.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft4.cs
index cf7b1e331f..82dfdeb31a 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft4.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft4.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//AKA mapper 068 (and TENGEN-800042)
 
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SxROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SxROM.cs
index 937763b012..64a151ae1e 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SxROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SxROM.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/TENGEN_800008.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/TENGEN_800008.cs
index caa1cb7031..d1a01ebebb 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/TENGEN_800008.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/TENGEN_800008.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	// tetris (unl)
 	// behaves identically to CNROM for the one board it is on, but supports more (64K prg, 64K chr)
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Taito_TC0190FMC.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Taito_TC0190FMC.cs
index 8cb4dd18f8..12edc8ad87 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Taito_TC0190FMC.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Taito_TC0190FMC.cs
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.Nintendo
+using BizHawk.Common;
+
+namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	//AKA mapper 033
 
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/UxROM.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/UxROM.cs
index 87501431af..134a15da9a 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/UxROM.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Boards/UxROM.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Core.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Core.cs
index 7621b29c99..9089aa937c 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Core.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Core.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+
+using BizHawk.Common;
 using BizHawk.Emulation.CPUs.M6502;
 
 #pragma warning disable 162
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/FDS.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/FDS.cs
index 515a1decbc..46348a8376 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/FDS.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/FDS.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Text;
 using System.IO;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/FDSAudio.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/FDSAudio.cs
index db42e30504..de3bd8e65b 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/FDSAudio.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/FDSAudio.cs
@@ -1,4 +1,5 @@
 using System;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/RamAdapter.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/RamAdapter.cs
index 3a85a346f1..8556100d20 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/RamAdapter.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/FDS/RamAdapter.cs
@@ -1,6 +1,8 @@
 using System;
 using System.IO;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	/// <summary>
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/NES.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/NES.cs
index ceb6c9575b..3b1b3db0bc 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/NES.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/NES.cs
@@ -3,6 +3,7 @@ using System.Linq;
 using System.IO;
 using System.Collections.Generic;
 
+using BizHawk.Common;
 //TODO - redo all timekeeping in terms of master clock
 
 namespace BizHawk.Emulation.Consoles.Nintendo
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/PPU.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/PPU.cs
index 7016b70e54..920b321199 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/PPU.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/PPU.cs
@@ -2,7 +2,7 @@
 
 using System;
 using System.Runtime.CompilerServices;
-
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/PPU.run.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/PPU.run.cs
index 3ea739aac8..68e08fc580 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/PPU.run.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/PPU.run.cs
@@ -4,6 +4,8 @@
 
 //TODO - correctly emulate PPU OFF state
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	partial class NES
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/Unif.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/Unif.cs
index 569b01f6cd..462e8a4a88 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/Unif.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/Unif.cs
@@ -4,6 +4,8 @@ using System.Linq;
 using System.Text;
 using System.IO;
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
 	/// <summary>
diff --git a/BizHawk.Emulation/Consoles/Nintendo/NES/iNES.cs b/BizHawk.Emulation/Consoles/Nintendo/NES/iNES.cs
index fe33b222ae..b62aba8dea 100644
--- a/BizHawk.Emulation/Consoles/Nintendo/NES/iNES.cs
+++ b/BizHawk.Emulation/Consoles/Nintendo/NES/iNES.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using BizHawk.Common;
 
 namespace BizHawk.Emulation.Consoles.Nintendo
 {
diff --git a/BizHawk.Emulation/Database/Database.cs b/BizHawk.Emulation/Database/Database.cs
index 77070200e3..fbbd9d6b71 100644
--- a/BizHawk.Emulation/Database/Database.cs
+++ b/BizHawk.Emulation/Database/Database.cs
@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.IO;
 using System.Threading;
 
+using BizHawk.Common;
+
 namespace BizHawk
 {
 	internal class CompactGameInfo
diff --git a/BizHawk.Emulation/Interfaces/Base Implementations/NullEmulator.cs b/BizHawk.Emulation/Interfaces/Base Implementations/NullEmulator.cs
index 1b9342c3f2..1bc6d355bb 100644
--- a/BizHawk.Emulation/Interfaces/Base Implementations/NullEmulator.cs	
+++ b/BizHawk.Emulation/Interfaces/Base Implementations/NullEmulator.cs	
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using BizHawk.Common;
 
 namespace BizHawk
 {
diff --git a/BizHawk.Emulation/Sound/YM2413.cs b/BizHawk.Emulation/Sound/YM2413.cs
index a706cf748e..163d2d9035 100644
--- a/BizHawk.Emulation/Sound/YM2413.cs
+++ b/BizHawk.Emulation/Sound/YM2413.cs
@@ -7,18 +7,20 @@
 // TODO The savestate support here is very simplistic and incomplete. However, this does not result in desyncs as the YM2413 is write-only.
 // TODO This should eventually be replaced, due to 1) uncertain licensing terms 2) This is not a native C# implementation, but a naive port.
 
+using BizHawk.Common;
+
 namespace BizHawk.Emulation.Sound
 {
-    public sealed class YM2413 : ISoundProvider
-    {
-        public byte DetectionValue;
-        public byte RegisterLatch;
+	public sealed class YM2413 : ISoundProvider
+	{
+		public byte DetectionValue;
+		public byte RegisterLatch;
 
-        public OPLL opll;
+		public OPLL opll;
 
-        public YM2413()
-        {
-            MaxVolume = short.MaxValue;
+		public YM2413()
+		{
+			MaxVolume = short.MaxValue;
 			opll = OPLL_new(3579545, 44100, 0);
 		}
 
@@ -34,55 +36,55 @@ namespace BizHawk.Emulation.Sound
 			opll = OPLL_new(3579545, 44100, (int)type);
 		}
 
-				public void SyncState(Serializer ser)
-				{
-					//TODO !! MUCH BETTER-NESS!
-					ser.Sync("RegisterLatch", ref RegisterLatch);
-				}
-
-		public void Reset() 
-        {
-			OPLL_reset(opll);
-			DetectionValue = 0;
-		    RegisterLatch = 0;
+		public void SyncState(Serializer ser)
+		{
+			//TODO !! MUCH BETTER-NESS!
+			ser.Sync("RegisterLatch", ref RegisterLatch);
 		}
 
-        public void Write(byte value)
-        {
-            OPLL_writeReg(opll, RegisterLatch, value);
-        }
+		public void Reset()
+		{
+			OPLL_reset(opll);
+			DetectionValue = 0;
+			RegisterLatch = 0;
+		}
 
-		public void Write(byte register, byte value) 
-        {
+		public void Write(byte value)
+		{
+			OPLL_writeReg(opll, RegisterLatch, value);
+		}
+
+		public void Write(byte register, byte value)
+		{
 			OPLL_writeReg(opll, register, value);
 		}
 
 		public void DiscardSamples() { }
-        public int MaxVolume { get; set; }
-        public void GetSamples(short[] samples)
-        {
-            for (int i=0; i<samples.Length;)
-            {
-                short val = (short)(calc(opll) * MaxVolume / short.MaxValue);
-                samples[i++] = val;
-                samples[i++] = val;
-            }
-        }
+		public int MaxVolume { get; set; }
+		public void GetSamples(short[] samples)
+		{
+			for (int i = 0; i < samples.Length; )
+			{
+				short val = (short)(calc(opll) * MaxVolume / short.MaxValue);
+				samples[i++] = val;
+				samples[i++] = val;
+			}
+		}
 
-        #region Implementation Uglyness
+		#region Implementation Uglyness
 
-        /* Mask */
-        static int OPLL_MASK_CH(int x) { return (1 << (x)); }
-        const int OPLL_MASK_HH = (1 << (9));
-        const int OPLL_MASK_CYM = (1 << (10));
-        const int OPLL_MASK_TOM = (1 << (11));
-        const int OPLL_MASK_SD = (1 << (12));
-        const int OPLL_MASK_BD = (1 << (13));
-        const int OPLL_MASK_RHYTHM = (OPLL_MASK_HH | OPLL_MASK_CYM | OPLL_MASK_TOM | OPLL_MASK_SD | OPLL_MASK_BD);
+		/* Mask */
+		static int OPLL_MASK_CH(int x) { return (1 << (x)); }
+		const int OPLL_MASK_HH = (1 << (9));
+		const int OPLL_MASK_CYM = (1 << (10));
+		const int OPLL_MASK_TOM = (1 << (11));
+		const int OPLL_MASK_SD = (1 << (12));
+		const int OPLL_MASK_BD = (1 << (13));
+		const int OPLL_MASK_RHYTHM = (OPLL_MASK_HH | OPLL_MASK_CYM | OPLL_MASK_TOM | OPLL_MASK_SD | OPLL_MASK_BD);
 
-        const int OPLL_TONE_NUM = 3;
+		const int OPLL_TONE_NUM = 3;
 
-        static byte[][] default_inst = new byte[3][] {
+		static byte[][] default_inst = new byte[3][] {
 			    new byte[] {
 				    0x49,0x4c,0x4c,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 				    0x61,0x61,0x1E,0x17,0xF0,0x7F,0x00,0x17,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
@@ -175,1687 +177,1687 @@ namespace BizHawk.Emulation.Sound
 			    }
 		    };
 
-        /* Size of Sintable ( 8 -- 18 can be used. 9 recommended.) */
-        const int PG_BITS = 9;
-        const int PG_WIDTH = (1 << PG_BITS);
+		/* Size of Sintable ( 8 -- 18 can be used. 9 recommended.) */
+		const int PG_BITS = 9;
+		const int PG_WIDTH = (1 << PG_BITS);
 
-        /* Phase increment counter */
-        const int DP_BITS = 18;
-        const int DP_WIDTH = (1 << DP_BITS);
-        const int DP_BASE_BITS = (DP_BITS - PG_BITS);
+		/* Phase increment counter */
+		const int DP_BITS = 18;
+		const int DP_WIDTH = (1 << DP_BITS);
+		const int DP_BASE_BITS = (DP_BITS - PG_BITS);
 
-        /* Dynamic range (Accuracy of sin table) */
-        const int DB_BITS = 8;
-        const double DB_STEP = (48.0 / (1 << DB_BITS));
-        const int DB_MUTE = (1 << DB_BITS);
+		/* Dynamic range (Accuracy of sin table) */
+		const int DB_BITS = 8;
+		const double DB_STEP = (48.0 / (1 << DB_BITS));
+		const int DB_MUTE = (1 << DB_BITS);
 
-        /* Dynamic range of envelope */
-        const double EG_STEP = 0.375;
-        const int EG_BITS = 7;
-        const int EG_MUTE = (1 << EG_BITS);
+		/* Dynamic range of envelope */
+		const double EG_STEP = 0.375;
+		const int EG_BITS = 7;
+		const int EG_MUTE = (1 << EG_BITS);
 
-        /* Dynamic range of total level */
-        const double TL_STEP = 0.75;
-        const int TL_BITS = 6;
-        const int TL_MUTE = (1 << TL_BITS);
+		/* Dynamic range of total level */
+		const double TL_STEP = 0.75;
+		const int TL_BITS = 6;
+		const int TL_MUTE = (1 << TL_BITS);
 
-        /* Dynamic range of sustine level */
-        const double SL_STEP = 3.0;
-        const int SL_BITS = 4;
-        const int SL_MUTE = (1 << SL_BITS);
+		/* Dynamic range of sustine level */
+		const double SL_STEP = 3.0;
+		const int SL_BITS = 4;
+		const int SL_MUTE = (1 << SL_BITS);
 
-        static uint EG2DB(uint d) { return ((d) * unchecked((int)(EG_STEP / DB_STEP))); }
-        static uint TL2EG(uint d) { return ((d) * unchecked((int)(TL_STEP / EG_STEP))); }
-        static uint SL2EG(uint d) { return ((d) * unchecked((int)(SL_STEP / EG_STEP))); }
+		static uint EG2DB(uint d) { return ((d) * unchecked((int)(EG_STEP / DB_STEP))); }
+		static uint TL2EG(uint d) { return ((d) * unchecked((int)(TL_STEP / EG_STEP))); }
+		static uint SL2EG(uint d) { return ((d) * unchecked((int)(SL_STEP / EG_STEP))); }
 
-        static uint DB_POS(double x) { return (uint)((x) / DB_STEP); }
-        static uint DB_NEG(double x) { return (uint)(DB_MUTE + DB_MUTE + (x) / DB_STEP); }
+		static uint DB_POS(double x) { return (uint)((x) / DB_STEP); }
+		static uint DB_NEG(double x) { return (uint)(DB_MUTE + DB_MUTE + (x) / DB_STEP); }
 
-        /* Bits for liner value */
-        const int DB2LIN_AMP_BITS = 8;
-        const int SLOT_AMP_BITS = (DB2LIN_AMP_BITS);
+		/* Bits for liner value */
+		const int DB2LIN_AMP_BITS = 8;
+		const int SLOT_AMP_BITS = (DB2LIN_AMP_BITS);
 
-        /* Bits for envelope phase incremental counter */
-        const int EG_DP_BITS = 22;
-        const int EG_DP_WIDTH = (1 << EG_DP_BITS);
+		/* Bits for envelope phase incremental counter */
+		const int EG_DP_BITS = 22;
+		const int EG_DP_WIDTH = (1 << EG_DP_BITS);
 
-        /* Bits for Pitch and Amp modulator */
-        const int PM_PG_BITS = 8;
-        const int PM_PG_WIDTH = (1 << PM_PG_BITS);
-        const int PM_DP_BITS = 16;
-        const int PM_DP_WIDTH = (1 << PM_DP_BITS);
-        const int AM_PG_BITS = 8;
-        const int AM_PG_WIDTH = (1 << AM_PG_BITS);
-        const int AM_DP_BITS = 16;
-        const int AM_DP_WIDTH = (1 << AM_DP_BITS);
+		/* Bits for Pitch and Amp modulator */
+		const int PM_PG_BITS = 8;
+		const int PM_PG_WIDTH = (1 << PM_PG_BITS);
+		const int PM_DP_BITS = 16;
+		const int PM_DP_WIDTH = (1 << PM_DP_BITS);
+		const int AM_PG_BITS = 8;
+		const int AM_PG_WIDTH = (1 << AM_PG_BITS);
+		const int AM_DP_BITS = 16;
+		const int AM_DP_WIDTH = (1 << AM_DP_BITS);
 
-        /* PM table is calcurated by PM_AMP * pow(2,PM_DEPTH*sin(x)/1200) */
-        const int PM_AMP_BITS = 8;
-        const int PM_AMP = (1 << PM_AMP_BITS);
+		/* PM table is calcurated by PM_AMP * pow(2,PM_DEPTH*sin(x)/1200) */
+		const int PM_AMP_BITS = 8;
+		const int PM_AMP = (1 << PM_AMP_BITS);
 
-        /* PM speed(Hz) and depth(cent) */
-        const double PM_SPEED = 6.068835788302951;
-        const double PM_DEPTH = 13.75;
+		/* PM speed(Hz) and depth(cent) */
+		const double PM_SPEED = 6.068835788302951;
+		const double PM_DEPTH = 13.75;
 
-        /* AM speed(Hz) and depth(dB) */
-        const double AM_SPEED = 3.6413;
-        const double AM_DEPTH = 4.875;
+		/* AM speed(Hz) and depth(dB) */
+		const double AM_SPEED = 3.6413;
+		const double AM_DEPTH = 4.875;
 
-        /* Cut the lower b bit(s) off. */
-        static uint HIGHBITS(uint c, int b) { return ((c) >> (b)); }
+		/* Cut the lower b bit(s) off. */
+		static uint HIGHBITS(uint c, int b) { return ((c) >> (b)); }
 
-        /* Leave the lower b bit(s). */
-        static int LOWBITS(int c, int b) { return ((c) & ((1 << (b)) - 1)); }
+		/* Leave the lower b bit(s). */
+		static int LOWBITS(int c, int b) { return ((c) & ((1 << (b)) - 1)); }
 
-        /* Expand x which is s bits to d bits. */
-        static int EXPAND_BITS(int x, int s, int d) { return ((x) << ((d) - (s))); }
+		/* Expand x which is s bits to d bits. */
+		static int EXPAND_BITS(int x, int s, int d) { return ((x) << ((d) - (s))); }
 
-        /* Expand x which is s bits to d bits and fill expanded bits '1' */
-        static int EXPAND_BITS_X(int x, int s, int d) { return (((x) << ((d) - (s))) | ((1 << ((d) - (s))) - 1)); }
+		/* Expand x which is s bits to d bits and fill expanded bits '1' */
+		static int EXPAND_BITS_X(int x, int s, int d) { return (((x) << ((d) - (s))) | ((1 << ((d) - (s))) - 1)); }
 
-        /* Adjust envelope speed which depends on sampling rate. */
-        static uint RATE_ADJUST(double x) { return (rate == 49716 ? (uint)x : (uint)((double)(x) * clk / 72 / rate + 0.5)); }        /* added 0.5 to round the value*/
+		/* Adjust envelope speed which depends on sampling rate. */
+		static uint RATE_ADJUST(double x) { return (rate == 49716 ? (uint)x : (uint)((double)(x) * clk / 72 / rate + 0.5)); }        /* added 0.5 to round the value*/
 
-        static OPLL_SLOT MOD(OPLL o, int x) { return ((o).slot[(x) << 1]); }
-        static OPLL_SLOT CAR(OPLL o, int x) { return ((o).slot[((x) << 1) | 1]); }
+		static OPLL_SLOT MOD(OPLL o, int x) { return ((o).slot[(x) << 1]); }
+		static OPLL_SLOT CAR(OPLL o, int x) { return ((o).slot[((x) << 1) | 1]); }
 
-        static bool BIT(uint s, int b) { return (((s) >> (b)) & 1) != 0; }
-        static bool BIT(int s, int b) { return (((s) >> (b)) & 1) != 0; }
+		static bool BIT(uint s, int b) { return (((s) >> (b)) & 1) != 0; }
+		static bool BIT(int s, int b) { return (((s) >> (b)) & 1) != 0; }
 
-        /* Input clock */
-        static uint clk = 844451141;
-        /* Sampling rate */
-        static uint rate = 3354932;
+		/* Input clock */
+		static uint clk = 844451141;
+		/* Sampling rate */
+		static uint rate = 3354932;
 
-        /* WaveTable for each envelope amp */
-        static short[] fullsintable = new short[PG_WIDTH];
-        static short[] halfsintable = new short[PG_WIDTH];
+		/* WaveTable for each envelope amp */
+		static short[] fullsintable = new short[PG_WIDTH];
+		static short[] halfsintable = new short[PG_WIDTH];
 
-        static short[][] waveform = new short[2][] { fullsintable, halfsintable };
+		static short[][] waveform = new short[2][] { fullsintable, halfsintable };
 
-        /* LFO Table */
-        static int[] pmtable = new int[PM_PG_WIDTH];
-        static int[] amtable = new int[AM_PG_WIDTH];
+		/* LFO Table */
+		static int[] pmtable = new int[PM_PG_WIDTH];
+		static int[] amtable = new int[AM_PG_WIDTH];
 
-        /* Phase delta for LFO */
-        static uint pm_dphase;
-        static uint am_dphase;
+		/* Phase delta for LFO */
+		static uint pm_dphase;
+		static uint am_dphase;
 
-        /* dB to Liner table */
-        static short[] DB2LIN_TABLE = new short[(DB_MUTE + DB_MUTE) * 2];
+		/* dB to Liner table */
+		static short[] DB2LIN_TABLE = new short[(DB_MUTE + DB_MUTE) * 2];
 
-        /* Liner to Log curve conversion table (for Attack rate). */
-        static short[] AR_ADJUST_TABLE = new short[1 << EG_BITS];
+		/* Liner to Log curve conversion table (for Attack rate). */
+		static short[] AR_ADJUST_TABLE = new short[1 << EG_BITS];
 
-        /* Empty voice data */
-        //static OPLL_PATCH null_patch = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+		/* Empty voice data */
+		//static OPLL_PATCH null_patch = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-        /* Basic voice Data */
-        static OPLL_PATCH[,] default_patch = new OPLL_PATCH[OPLL_TONE_NUM, (16 + 3) * 2];
+		/* Basic voice Data */
+		static OPLL_PATCH[,] default_patch = new OPLL_PATCH[OPLL_TONE_NUM, (16 + 3) * 2];
 
-        /* Definition of envelope mode */
-        public enum OPLL_EG_STATE { READY, ATTACK, DECAY, SUSHOLD, SUSTINE, RELEASE, SETTLE, FINISH };
+		/* Definition of envelope mode */
+		public enum OPLL_EG_STATE { READY, ATTACK, DECAY, SUSHOLD, SUSTINE, RELEASE, SETTLE, FINISH };
 
-        /* Phase incr table for Attack */
-        static uint[,] dphaseARTable = new uint[16, 16];
-        /* Phase incr table for Decay and Release */
-        static uint[,] dphaseDRTable = new uint[16, 16];
+		/* Phase incr table for Attack */
+		static uint[,] dphaseARTable = new uint[16, 16];
+		/* Phase incr table for Decay and Release */
+		static uint[,] dphaseDRTable = new uint[16, 16];
 
-        /* KSL + TL Table */
-        static uint[, , ,] tllTable = new uint[16, 8, 1 << TL_BITS, 4];
-        static int[, ,] rksTable = new int[2, 8, 2];
+		/* KSL + TL Table */
+		static uint[, , ,] tllTable = new uint[16, 8, 1 << TL_BITS, 4];
+		static int[, ,] rksTable = new int[2, 8, 2];
 
-        /* Phase incr table for PG */
-        static uint[, ,] dphaseTable = new uint[512, 8, 16];
+		/* Phase incr table for PG */
+		static uint[, ,] dphaseTable = new uint[512, 8, 16];
 
-        /***************************************************
+		/***************************************************
  
-                  Create tables
+				  Create tables
  
-        ****************************************************/
-        static int Min(int i, int j)
-        {
-            if (i < j)
-                return i;
-            else
-                return j;
-        }
+		****************************************************/
+		static int Min(int i, int j)
+		{
+			if (i < j)
+				return i;
+			else
+				return j;
+		}
 
-        /* Table for AR to LogCurve. */
-        static void makeAdjustTable()
-        {
-            AR_ADJUST_TABLE[0] = (1 << EG_BITS) - 1;
-            for (int i = 1; i < (1 << EG_BITS); i++)
-                AR_ADJUST_TABLE[i] = (short)((double)(1 << EG_BITS) - 1 - ((1 << EG_BITS) - 1) * Math.Log(i) / Math.Log10(127));
-        }
+		/* Table for AR to LogCurve. */
+		static void makeAdjustTable()
+		{
+			AR_ADJUST_TABLE[0] = (1 << EG_BITS) - 1;
+			for (int i = 1; i < (1 << EG_BITS); i++)
+				AR_ADJUST_TABLE[i] = (short)((double)(1 << EG_BITS) - 1 - ((1 << EG_BITS) - 1) * Math.Log(i) / Math.Log10(127));
+		}
 
 
-        /* Table for dB(0 -- (1<<DB_BITS)-1) to Liner(0 -- DB2LIN_AMP_WIDTH) */
-        static void makeDB2LinTable()
-        {
-            for (int i = 0; i < DB_MUTE + DB_MUTE; i++)
-            {
-                DB2LIN_TABLE[i] = (short)((double)((1 << DB2LIN_AMP_BITS) - 1) * Math.Pow(10, -(double)i * DB_STEP / 20));
-                if (i >= DB_MUTE) DB2LIN_TABLE[i] = 0;
-                DB2LIN_TABLE[i + DB_MUTE + DB_MUTE] = (short)(-DB2LIN_TABLE[i]);
-            }
-        }
+		/* Table for dB(0 -- (1<<DB_BITS)-1) to Liner(0 -- DB2LIN_AMP_WIDTH) */
+		static void makeDB2LinTable()
+		{
+			for (int i = 0; i < DB_MUTE + DB_MUTE; i++)
+			{
+				DB2LIN_TABLE[i] = (short)((double)((1 << DB2LIN_AMP_BITS) - 1) * Math.Pow(10, -(double)i * DB_STEP / 20));
+				if (i >= DB_MUTE) DB2LIN_TABLE[i] = 0;
+				DB2LIN_TABLE[i + DB_MUTE + DB_MUTE] = (short)(-DB2LIN_TABLE[i]);
+			}
+		}
 
-        /* Liner(+0.0 - +1.0) to dB((1<<DB_BITS) - 1 -- 0) */
-        static int lin2db(double d)
-        {
-            if (d == 0)
-                return (DB_MUTE - 1);
-            else
-                return Min(-(int)(20.0 * Math.Log10(d) / DB_STEP), DB_MUTE - 1);  /* 0 -- 127 */
-        }
+		/* Liner(+0.0 - +1.0) to dB((1<<DB_BITS) - 1 -- 0) */
+		static int lin2db(double d)
+		{
+			if (d == 0)
+				return (DB_MUTE - 1);
+			else
+				return Min(-(int)(20.0 * Math.Log10(d) / DB_STEP), DB_MUTE - 1);  /* 0 -- 127 */
+		}
 
 
-        /* Sin Table */
-        static void makeSinTable()
-        {
-            int i;
+		/* Sin Table */
+		static void makeSinTable()
+		{
+			int i;
 
-            for (i = 0; i < PG_WIDTH / 4; i++)
-            {
-                fullsintable[i] = (short)lin2db(Math.Sin(2.0 * Math.PI * i / PG_WIDTH));
-            }
+			for (i = 0; i < PG_WIDTH / 4; i++)
+			{
+				fullsintable[i] = (short)lin2db(Math.Sin(2.0 * Math.PI * i / PG_WIDTH));
+			}
 
-            for (i = 0; i < PG_WIDTH / 4; i++)
-            {
-                fullsintable[PG_WIDTH / 2 - 1 - i] = fullsintable[i];
-            }
+			for (i = 0; i < PG_WIDTH / 4; i++)
+			{
+				fullsintable[PG_WIDTH / 2 - 1 - i] = fullsintable[i];
+			}
 
-            for (i = 0; i < PG_WIDTH / 2; i++)
-            {
-                fullsintable[PG_WIDTH / 2 + i] = (short)(DB_MUTE + DB_MUTE + fullsintable[i]);
-            }
+			for (i = 0; i < PG_WIDTH / 2; i++)
+			{
+				fullsintable[PG_WIDTH / 2 + i] = (short)(DB_MUTE + DB_MUTE + fullsintable[i]);
+			}
 
-            for (i = 0; i < PG_WIDTH / 2; i++)
-                halfsintable[i] = fullsintable[i];
-            for (i = PG_WIDTH / 2; i < PG_WIDTH; i++)
-                halfsintable[i] = fullsintable[0];
-        }
+			for (i = 0; i < PG_WIDTH / 2; i++)
+				halfsintable[i] = fullsintable[i];
+			for (i = PG_WIDTH / 2; i < PG_WIDTH; i++)
+				halfsintable[i] = fullsintable[0];
+		}
 
-        static double saw(double phase)
-        {
-            if (phase <= Math.PI / 2)
-                return phase * 2 / Math.PI;
-            else if (phase <= Math.PI * 3 / 2)
-                return 2.0 - (phase * 2 / Math.PI);
-            else
-                return -4.0 + phase * 2 / Math.PI;
-        }
+		static double saw(double phase)
+		{
+			if (phase <= Math.PI / 2)
+				return phase * 2 / Math.PI;
+			else if (phase <= Math.PI * 3 / 2)
+				return 2.0 - (phase * 2 / Math.PI);
+			else
+				return -4.0 + phase * 2 / Math.PI;
+		}
 
-        /* Table for Pitch Modulator */
-        static void makePmTable()
-        {
-            for (int i = 0; i < PM_PG_WIDTH; i++)
-                pmtable[i] = (int)((double)PM_AMP * Math.Pow(2, (double)PM_DEPTH * saw(2.0 * Math.PI * i / PM_PG_WIDTH) / 1200));
-        }
+		/* Table for Pitch Modulator */
+		static void makePmTable()
+		{
+			for (int i = 0; i < PM_PG_WIDTH; i++)
+				pmtable[i] = (int)((double)PM_AMP * Math.Pow(2, (double)PM_DEPTH * saw(2.0 * Math.PI * i / PM_PG_WIDTH) / 1200));
+		}
 
-        /* Table for Amp Modulator */
-        static void makeAmTable()
-        {
-            for (int i = 0; i < AM_PG_WIDTH; i++)
-                amtable[i] = (int)((double)AM_DEPTH / 2 / DB_STEP * (1.0 + saw(2.0 * Math.PI * i / PM_PG_WIDTH)));
-        }
+		/* Table for Amp Modulator */
+		static void makeAmTable()
+		{
+			for (int i = 0; i < AM_PG_WIDTH; i++)
+				amtable[i] = (int)((double)AM_DEPTH / 2 / DB_STEP * (1.0 + saw(2.0 * Math.PI * i / PM_PG_WIDTH)));
+		}
 
-        /* Phase increment counter table */
-        static void makeDphaseTable()
-        {
-            uint fnum, block, ML;
-            uint[] mltable = new uint[] { 1, 1 * 2, 2 * 2, 3 * 2, 4 * 2, 5 * 2, 6 * 2, 7 * 2, 8 * 2, 9 * 2, 10 * 2, 10 * 2, 12 * 2, 12 * 2, 15 * 2, 15 * 2 };
+		/* Phase increment counter table */
+		static void makeDphaseTable()
+		{
+			uint fnum, block, ML;
+			uint[] mltable = new uint[] { 1, 1 * 2, 2 * 2, 3 * 2, 4 * 2, 5 * 2, 6 * 2, 7 * 2, 8 * 2, 9 * 2, 10 * 2, 10 * 2, 12 * 2, 12 * 2, 15 * 2, 15 * 2 };
 
-            for (fnum = 0; fnum < 512; fnum++)
-                for (block = 0; block < 8; block++)
-                    for (ML = 0; ML < 16; ML++)
-                        dphaseTable[fnum, block, ML] = RATE_ADJUST(((fnum * mltable[ML]) << (int)block) >> (20 - DP_BITS));
-        }
+			for (fnum = 0; fnum < 512; fnum++)
+				for (block = 0; block < 8; block++)
+					for (ML = 0; ML < 16; ML++)
+						dphaseTable[fnum, block, ML] = RATE_ADJUST(((fnum * mltable[ML]) << (int)block) >> (20 - DP_BITS));
+		}
 
-        static double dB2(double x) { return ((x) * 2); }
+		static double dB2(double x) { return ((x) * 2); }
 
-        static void makeTllTable()
-        {
-            double[] kltable = new double[] {
+		static void makeTllTable()
+		{
+			double[] kltable = new double[] {
 				    dB2 (0.000), dB2 (9.000), dB2 (12.000), dB2 (13.875), dB2 (15.000), dB2 (16.125), dB2 (16.875), dB2 (17.625),
 				    dB2 (18.000), dB2 (18.750), dB2 (19.125), dB2 (19.500), dB2 (19.875), dB2 (20.250), dB2 (20.625), dB2 (21.000)
 			    };
 
-            int tmp;
-            int fnum, block, TL, KL;
-
-            for (fnum = 0; fnum < 16; fnum++)
-                for (block = 0; block < 8; block++)
-                    for (TL = 0; TL < 64; TL++)
-                        for (KL = 0; KL < 4; KL++)
-                        {
-                            if (KL == 0)
-                            {
-                                tllTable[fnum, block, TL, KL] = TL2EG((uint)TL);
-                            }
-                            else
-                            {
-                                tmp = (int)(kltable[fnum] - dB2(3.000) * (7 - block));
-                                if (tmp <= 0)
-                                    tllTable[fnum, block, TL, KL] = TL2EG((uint)TL);
-                                else
-                                    tllTable[fnum, block, TL, KL] = (uint)((tmp >> (3 - KL)) / EG_STEP) + TL2EG((uint)TL);
-                            }
-                        }
-        }
-
-        /* Rate Table for Attack */
-        static void makeDphaseARTable()
-        {
-            int AR, Rks, RM, RL;
-
-            for (AR = 0; AR < 16; AR++)
-                for (Rks = 0; Rks < 16; Rks++)
-                {
-                    RM = AR + (Rks >> 2);
-                    RL = Rks & 3;
-                    if (RM > 15)
-                        RM = 15;
-                    switch (AR)
-                    {
-                        case 0:
-                            dphaseARTable[AR, Rks] = 0;
-                            break;
-                        case 15:
-                            dphaseARTable[AR, Rks] = 0;/*EG_DP_WIDTH;*/
-                            break;
-                        default:
-                            dphaseARTable[AR, Rks] = RATE_ADJUST((uint)((3 * (RL + 4) << (RM + 1))));
-                            break;
-                    }
-                }
-        }
-
-        /* Rate Table for Decay and Release */
-        static void makeDphaseDRTable()
-        {
-            int DR, Rks, RM, RL;
-
-            for (DR = 0; DR < 16; DR++)
-                for (Rks = 0; Rks < 16; Rks++)
-                {
-                    RM = DR + (Rks >> 2);
-                    RL = Rks & 3;
-                    if (RM > 15)
-                        RM = 15;
-                    switch (DR)
-                    {
-                        case 0:
-                            dphaseDRTable[DR, Rks] = 0;
-                            break;
-                        default:
-                            dphaseDRTable[DR, Rks] = RATE_ADJUST((uint)((RL + 4) << (RM - 1)));
-                            break;
-                    }
-                }
-        }
-
-        static void makeRksTable()
-        {
-            int fnum8, block, KR;
-
-            for (fnum8 = 0; fnum8 < 2; fnum8++)
-                for (block = 0; block < 8; block++)
-                    for (KR = 0; KR < 2; KR++)
-                    {
-                        if (KR != 0)
-                            rksTable[fnum8, block, KR] = (block << 1) + fnum8;
-                        else
-                            rksTable[fnum8, block, KR] = block >> 1;
-                    }
-        }
-
-        static void OPLL_dump2patch(byte[] dump, OPLL_PATCH[] patch)
-        {
-            patch[0].am = (uint)(dump[0] >> 7) & 1;
-            patch[1].am = (uint)(dump[1] >> 7) & 1;
-            patch[0].pm = (uint)(dump[0] >> 6) & 1;
-            patch[1].pm = (uint)(dump[1] >> 6) & 1;
-            patch[0].eg = (uint)(dump[0] >> 5) & 1;
-            patch[1].eg = (uint)(dump[1] >> 5) & 1;
-            patch[0].kr = (uint)(dump[0] >> 4) & 1;
-            patch[1].kr = (uint)(dump[1] >> 4) & 1;
-            patch[0].ml = (uint)(dump[0]) & 15;
-            patch[1].ml = (uint)(dump[1]) & 15;
-            patch[0].kl = (uint)(dump[2] >> 6) & 3;
-            patch[1].kl = (uint)(dump[3] >> 6) & 3;
-            patch[0].tl = (uint)(dump[2]) & 63;
-            patch[0].fb = (uint)(dump[3]) & 7;
-            patch[0].wf = (uint)(dump[3] >> 3) & 1;
-            patch[1].wf = (uint)(dump[3] >> 4) & 1;
-            patch[0].ar = (uint)(dump[4] >> 4) & 15;
-            patch[1].ar = (uint)(dump[5] >> 4) & 15;
-            patch[0].dr = (uint)(dump[4]) & 15;
-            patch[1].dr = (uint)(dump[5]) & 15;
-            patch[0].sl = (uint)(dump[6] >> 4) & 15;
-            patch[1].sl = (uint)(dump[7] >> 4) & 15;
-            patch[0].rr = (uint)(dump[6]) & 15;
-            patch[1].rr = (uint)(dump[7]) & 15;
-        }
-
-        static void
-        OPLL_getDefaultPatch(int type, int num, OPLL_PATCH[] patch)
-        {
-            byte[] r = new byte[8];
-            Array.Copy(default_inst[type], num * 16, r, 0, r.Length);
-            OPLL_dump2patch(r, patch);
-        }
-
-        static void makeDefaultPatch()
-        {
-            for (int i = 0; i < OPLL_TONE_NUM; i++)
-            {
-                for (int j = 0; j < 19; j++)
-                {
-                    default_patch[i, j * 2 + 0] = new OPLL_PATCH();
-                    default_patch[i, j * 2 + 1] = new OPLL_PATCH();
-                    OPLL_getDefaultPatch(i, j, new[] { default_patch[i, j * 2 + 0], default_patch[i, j * 2 + 1] });
-                }
-            }
-        }
-
-        /************************************************************
-
-                              Calc Parameters
-
-        ************************************************************/
-
-        static uint calc_eg_dphase(OPLL_SLOT slot)
-        {
-            switch (slot.eg_mode)
-            {
-                case OPLL_EG_STATE.ATTACK:
-                    return dphaseARTable[slot.patch.ar, slot.rks];
-
-                case OPLL_EG_STATE.DECAY:
-                    return dphaseDRTable[slot.patch.dr, slot.rks];
-
-                case OPLL_EG_STATE.SUSHOLD:
-                    return 0;
-
-                case OPLL_EG_STATE.SUSTINE:
-                    return dphaseDRTable[slot.patch.rr, slot.rks];
-
-                case OPLL_EG_STATE.RELEASE:
-                    if (slot.sustine != 0)
-                        return dphaseDRTable[5, slot.rks];
-                    else if (slot.patch.eg != 0)
-                        return dphaseDRTable[slot.patch.rr, slot.rks];
-                    else
-                        return dphaseDRTable[7, slot.rks];
-
-                case OPLL_EG_STATE.SETTLE:
-                    return dphaseDRTable[15, 0];
-
-                case OPLL_EG_STATE.FINISH:
-                    return 0;
-
-                default:
-                    return 0;
-            }
-        }
-
-        /*************************************************************
-
-                            OPLL public interfaces
-
-        *************************************************************/
-
-        const int SLOT_BD1 = 12;
-        const int SLOT_BD2 = 13;
-        const int SLOT_HH = 14;
-        const int SLOT_SD = 15;
-        const int SLOT_TOM = 16;
-        const int SLOT_CYM = 17;
-
-        static void UPDATE_PG(OPLL_SLOT S) { (S).dphase = dphaseTable[(S).fnum, (S).block, (S).patch.ml]; }
-        static void UPDATE_TLL(OPLL_SLOT S)
-        {
-            if (S.type == 0)
-            {
-                (S).tll = tllTable[((S).fnum) >> 5, (S).block, (S).patch.tl, (S).patch.kl];
-            }
-            else
-            {
-                (S).tll = tllTable[((S).fnum) >> 5, (S).block, (S).volume, (S).patch.kl];
-            }
-        }
-        static void UPDATE_RKS(OPLL_SLOT S) { (S).rks = (uint)rksTable[((S).fnum) >> 8, (S).block, (S).patch.kr]; }
-        static void UPDATE_WF(OPLL_SLOT S) { (S).sintbl = waveform[(S).patch.wf]; }
-        static void UPDATE_EG(OPLL_SLOT S) { (S).eg_dphase = calc_eg_dphase(S); }
-        static void UPDATE_ALL(OPLL_SLOT S)
-        {
-            UPDATE_PG(S);
-            UPDATE_TLL(S);
-            UPDATE_RKS(S);
-            UPDATE_WF(S);
-            UPDATE_EG(S);                  /* EG should be updated last. */
-        }
-
-        /* Slot key on  */
-        static void slotOn(OPLL_SLOT slot)
-        {
-            slot.eg_mode = OPLL_EG_STATE.ATTACK;
-            slot.eg_phase = 0;
-            slot.phase = 0;
-            UPDATE_EG(slot);
-        }
-
-        /* Slot key on without reseting the phase */
-        static void slotOn2(OPLL_SLOT slot)
-        {
-            slot.eg_mode = OPLL_EG_STATE.ATTACK;
-            slot.eg_phase = 0;
-            UPDATE_EG(slot);
-        }
-
-        /* Slot key off */
-        static void slotOff(OPLL_SLOT slot)
-        {
-            if (slot.eg_mode == OPLL_EG_STATE.ATTACK)
-                slot.eg_phase = (uint)EXPAND_BITS(AR_ADJUST_TABLE[HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS)], EG_BITS, EG_DP_BITS);
-            slot.eg_mode = OPLL_EG_STATE.RELEASE;
-            UPDATE_EG(slot);
-        }
-
-        /* Channel key on */
-        static void keyOn(OPLL opll, int i)
-        {
-            if (opll.slot_on_flag[i * 2] == 0)
-                slotOn(MOD(opll, i));
-            if (opll.slot_on_flag[i * 2 + 1] == 0)
-                slotOn(CAR(opll, i));
-            opll.key_status[i] = 1;
-        }
-
-        /* Channel key off */
-        static void keyOff(OPLL opll, int i)
-        {
-            if (opll.slot_on_flag[i * 2 + 1] != 0)
-                slotOff(CAR(opll, i));
-            opll.key_status[i] = 0;
-        }
-
-        static void keyOn_BD(OPLL opll)
-        {
-            keyOn(opll, 6);
-        }
-
-        static void keyOn_SD(OPLL opll)
-        {
-            if (opll.slot_on_flag[SLOT_SD] == 0)
-                slotOn(CAR(opll, 7));
-        }
-
-        static void keyOn_TOM(OPLL opll)
-        {
-            if (opll.slot_on_flag[SLOT_TOM] == 0)
-                slotOn(MOD(opll, 8));
-        }
-
-        static void keyOn_HH(OPLL opll)
-        {
-            if (opll.slot_on_flag[SLOT_HH] == 0)
-                slotOn2(MOD(opll, 7));
-        }
-        
-        static void keyOn_CYM(OPLL opll)
-        {
-            if (opll.slot_on_flag[SLOT_CYM] == 0)
-                slotOn2(CAR(opll, 8));
-        }
-
-        /* Drum key off */
-        static void keyOff_BD(OPLL opll)
-        {
-            keyOff(opll, 6);
-        }
-
-        static void keyOff_SD(OPLL opll)
-        {
-            if (opll.slot_on_flag[SLOT_SD] == 0)
-                slotOff(CAR(opll, 7));
-        }
-
-        static void keyOff_TOM(OPLL opll)
-        {
-            if (opll.slot_on_flag[SLOT_TOM] != 0)
-                slotOff(MOD(opll, 8));
-        }
-
-        static void keyOff_HH(OPLL opll)
-        {
-            if (opll.slot_on_flag[SLOT_HH] != 0)
-                slotOff(MOD(opll, 7));
-        }
-
-        static void keyOff_CYM(OPLL opll)
-        {
-            if (opll.slot_on_flag[SLOT_CYM] != 0)
-                slotOff(CAR(opll, 8));
-        }
-
-        /* Change a voice */
-        static void setPatch(OPLL opll, int i, int num)
-        {
-            opll.patch_number[i] = num;
-            MOD(opll, i).patch = opll.patch[num * 2 + 0];
-            CAR(opll, i).patch = opll.patch[num * 2 + 1];
-        }
-
-        /* Change a rhythm voice */
-        static void setSlotPatch(OPLL_SLOT slot, OPLL_PATCH patch)
-        {
-            slot.patch = patch;
-        }
-
-        /* Set sustine parameter */
-        static void setSustine(OPLL opll, int c, int sustine)
-        {
-            CAR(opll, c).sustine = sustine;
-            if (MOD(opll, c).type != 0)
-                MOD(opll, c).sustine = sustine;
-        }
-
-        /* Volume : 6bit ( Volume register << 2 ) */
-        static void setVolume(OPLL opll, int c, int volume)
-        {
-            CAR(opll, c).volume = volume;
-        }
-
-        static void setSlotVolume(OPLL_SLOT slot, int volume)
-        {
-            slot.volume = volume;
-        }
-
-        /* Set F-Number ( fnum : 9bit ) */
-        static void setFnumber(OPLL opll, int c, int fnum)
-        {
-            CAR(opll, c).fnum = fnum;
-            MOD(opll, c).fnum = fnum;
-        }
-
-        /* Set Block data (block : 3bit ) */
-        static void setBlock(OPLL opll, int c, int block)
-        {
-            CAR(opll, c).block = block;
-            MOD(opll, c).block = block;
-        }
-
-        /* Change Rhythm Mode */
-        static void update_rhythm_mode(OPLL opll)
-        {
-            if ((opll.patch_number[6] & 0x10) != 0)
-            {
-                if ((opll.slot_on_flag[SLOT_BD2] | (opll.reg[0x0e] & 32)) == 0)
-                {
-                    opll.slot[SLOT_BD1].eg_mode = OPLL_EG_STATE.FINISH;
-                    opll.slot[SLOT_BD2].eg_mode = OPLL_EG_STATE.FINISH;
-                    setPatch(opll, 6, opll.reg[0x36] >> 4);
-                }
-            }
-            else if ((opll.reg[0x0e] & 32) != 0)
-            {
-                opll.patch_number[6] = 16;
-                opll.slot[SLOT_BD1].eg_mode = OPLL_EG_STATE.FINISH;
-                opll.slot[SLOT_BD2].eg_mode = OPLL_EG_STATE.FINISH;
-                setSlotPatch(opll.slot[SLOT_BD1], opll.patch[16 * 2 + 0]);
-                setSlotPatch(opll.slot[SLOT_BD2], opll.patch[16 * 2 + 1]);
-            }
-
-            if ((opll.patch_number[7] & 0x10) != 0)
-            {
-                if (!((opll.slot_on_flag[SLOT_HH] != 0 && opll.slot_on_flag[SLOT_SD] != 0) | ((opll.reg[0x0e] & 32) != 0)))
-                {
-                    opll.slot[SLOT_HH].type = 0;
-                    opll.slot[SLOT_HH].eg_mode = OPLL_EG_STATE.FINISH;
-                    opll.slot[SLOT_SD].eg_mode = OPLL_EG_STATE.FINISH;
-                    setPatch(opll, 7, opll.reg[0x37] >> 4);
-                }
-            }
-            else if ((opll.reg[0x0e] & 32) != 0)
-            {
-                opll.patch_number[7] = 17;
-                opll.slot[SLOT_HH].type = 1;
-                opll.slot[SLOT_HH].eg_mode = OPLL_EG_STATE.FINISH;
-                opll.slot[SLOT_SD].eg_mode = OPLL_EG_STATE.FINISH;
-                setSlotPatch(opll.slot[SLOT_HH], opll.patch[17 * 2 + 0]);
-                setSlotPatch(opll.slot[SLOT_SD], opll.patch[17 * 2 + 1]);
-            }
-
-            if ((opll.patch_number[8] & 0x10) != 0)
-            {
-                if (!((opll.slot_on_flag[SLOT_CYM] != 0 && opll.slot_on_flag[SLOT_TOM] != 0) | ((opll.reg[0x0e] & 32) != 0)))
-                {
-                    opll.slot[SLOT_TOM].type = 0;
-                    opll.slot[SLOT_TOM].eg_mode = OPLL_EG_STATE.FINISH;
-                    opll.slot[SLOT_CYM].eg_mode = OPLL_EG_STATE.FINISH;
-                    setPatch(opll, 8, opll.reg[0x38] >> 4);
-                }
-            }
-            else if ((opll.reg[0x0e] & 32) != 0)
-            {
-                opll.patch_number[8] = 18;
-                opll.slot[SLOT_TOM].type = 1;
-                opll.slot[SLOT_TOM].eg_mode = OPLL_EG_STATE.FINISH;
-                opll.slot[SLOT_CYM].eg_mode = OPLL_EG_STATE.FINISH;
-                setSlotPatch(opll.slot[SLOT_TOM], opll.patch[18 * 2 + 0]);
-                setSlotPatch(opll.slot[SLOT_CYM], opll.patch[18 * 2 + 1]);
-            }
-        }
-
-        static void update_key_status(OPLL opll)
-        {
-            int ch;
-
-            for (ch = 0; ch < 9; ch++)
-                opll.slot_on_flag[ch * 2] = opll.slot_on_flag[ch * 2 + 1] = (opll.reg[0x20 + ch]) & 0x10;
-
-            if ((opll.reg[0x0e] & 32) != 0)
-            {
-                opll.slot_on_flag[SLOT_BD1] |= (opll.reg[0x0e] & 0x10);
-                opll.slot_on_flag[SLOT_BD2] |= (opll.reg[0x0e] & 0x10);
-                opll.slot_on_flag[SLOT_SD] |= (opll.reg[0x0e] & 0x08);
-                opll.slot_on_flag[SLOT_HH] |= (opll.reg[0x0e] & 0x01);
-                opll.slot_on_flag[SLOT_TOM] |= (opll.reg[0x0e] & 0x04);
-                opll.slot_on_flag[SLOT_CYM] |= (opll.reg[0x0e] & 0x02);
-            }
-        }
-
-        void OPLL_copyPatch(OPLL opll, int num, OPLL_PATCH patch)
-        {
-            opll.patch[num] = (OPLL_PATCH)patch.Clone();
-        }
-
-        /***********************************************************
-
-                      Initializing
-
-        ***********************************************************/
-
-        static void OPLL_SLOT_reset(OPLL_SLOT slot, int type)
-        {
-            slot.type = type;
-            slot.sintbl = waveform[0];
-            slot.phase = 0;
-            slot.dphase = 0;
-            slot.output[0] = 0;
-            slot.output[1] = 0;
-            slot.feedback = 0;
-            slot.eg_mode = OPLL_EG_STATE.FINISH;
-            slot.eg_phase = EG_DP_WIDTH;
-            slot.eg_dphase = 0;
-            slot.rks = 0;
-            slot.tll = 0;
-            slot.sustine = 0;
-            slot.fnum = 0;
-            slot.block = 0;
-            slot.volume = 0;
-            slot.pgout = 0;
-            slot.egout = 0;
-            slot.patch = new OPLL_PATCH();
-        }
-
-        static void public_refresh()
-        {
-            makeDphaseTable();
-            makeDphaseARTable();
-            makeDphaseDRTable();
-            pm_dphase = (uint)RATE_ADJUST(PM_SPEED * PM_DP_WIDTH / (clk / 72));
-            am_dphase = (uint)RATE_ADJUST(AM_SPEED * AM_DP_WIDTH / (clk / 72));
-        }
-
-        static void maketables(uint c, uint r)
-        {
-            if (c != clk)
-            {
-                clk = c;
-                makePmTable();
-                makeAmTable();
-                makeDB2LinTable();
-                makeAdjustTable();
-                makeTllTable();
-                makeRksTable();
-                makeSinTable();
-                makeDefaultPatch();
-            }
-
-            if (r != rate)
-            {
-                rate = r;
-                public_refresh();
-            }
-        }
-
-        OPLL OPLL_new(uint clk, uint rate, int type)
-        {
-            OPLL opll = new OPLL();
-            int i;
-
-            maketables(clk, rate);
-
-            for (i = 0; i < 19 * 2; i++)
-                opll.patch[i] = new OPLL_PATCH();
-
-            opll.mask = 0;
-
-            OPLL_reset(opll);
-            OPLL_reset_patch(opll, type);
-
-            return opll;
-        }
-
-        /* Reset patch datas by system default. */
-        void OPLL_reset_patch(OPLL opll, int type)
-        {
-            int i;
-
-            for (i = 0; i < 19 * 2; i++)
-                OPLL_copyPatch(opll, i, default_patch[type % OPLL_TONE_NUM, i]);
-        }
-
-        /* Reset whole of OPLL except patch datas. */
-        void OPLL_reset(OPLL opll)
-        {
-            int i;
-
-            opll.adr = 0;
-            opll.output = 0;
-
-            opll.pm_phase = 0;
-            opll.am_phase = 0;
-
-            opll.noise_seed = 0xffff;
-            opll.mask = 0;
-
-            for (i = 0; i < 18; i++)
-                OPLL_SLOT_reset(opll.slot[i], i % 2);
-
-            for (i = 0; i < 9; i++)
-            {
-                opll.key_status[i] = 0;
-                setPatch(opll, i, 0);
-            }
-
-            for (i = 0; i < 0x40; i++)
-                OPLL_writeReg(opll, (uint)i, 0);
-
-            opll.realstep = (uint)((1 << 31) / rate);
-            opll.opllstep = (uint)((1 << 31) / (clk / 72));
-            opll.oplltime = 0;
-            for (i = 0; i < 14; i++)
-                opll.pan[i] = 3;
-            opll.sprev[0] = opll.sprev[1] = 0;
-            opll.snext[0] = opll.snext[1] = 0;
-
-        }
-
-        /* Force Refresh (When external program changes some parameters). */
-        void OPLL_forceRefresh(OPLL opll)
-        {
-            int i;
-
-            if (opll == null)
-                return;
-
-            for (i = 0; i < 9; i++)
-                setPatch(opll, i, opll.patch_number[i]);
-
-            for (i = 0; i < 18; i++)
-            {
-                UPDATE_PG(opll.slot[i]);
-                UPDATE_RKS(opll.slot[i]);
-                UPDATE_TLL(opll.slot[i]);
-                UPDATE_WF(opll.slot[i]);
-                UPDATE_EG(opll.slot[i]);
-            }
-        }
-
-        void OPLL_set_rate(OPLL opll, uint r)
-        {
-            if (opll.quality)
-                rate = 49716;
-            else
-                rate = r;
-            public_refresh();
-            rate = r;
-        }
-
-        void OPLL_set_quality(OPLL opll, bool q)
-        {
-            opll.quality = q;
-            OPLL_set_rate(opll, rate);
-        }
-
-        /*********************************************************
-
-                 Generate wave data
-
-        *********************************************************/
-
-        /* Convert Amp(0 to EG_HEIGHT) to Phase(0 to 2PI). */
-        static int wave2_2pi(int e)
-        {
-            return ((SLOT_AMP_BITS - PG_BITS) > 0) ?
-                ((e) >> (SLOT_AMP_BITS - PG_BITS)) :
-                ((e) << (PG_BITS - SLOT_AMP_BITS));
-        }
-
-        /* Convert Amp(0 to EG_HEIGHT) to Phase(0 to 4PI). */
-        static int wave2_4pi(int e)
-        {
-            return ((e) << (1 + PG_BITS - SLOT_AMP_BITS));
-            /*if ((SLOT_AMP_BITS - PG_BITS - 1) == 0) {
-                return (e);
-            } else if ((SLOT_AMP_BITS - PG_BITS - 1) > 0) {
-                return ((e) >> (SLOT_AMP_BITS - PG_BITS - 1));
-            } else {
-                return ((e) << (1 + PG_BITS - SLOT_AMP_BITS));
-            }*/
-        }
-        /* Convert Amp(0 to EG_HEIGHT) to Phase(0 to 8PI). */
-        static int wave2_8pi(int e)
-        {
-            return ((e) << (2 + PG_BITS - SLOT_AMP_BITS));
-            /*
-            if ((SLOT_AMP_BITS - PG_BITS - 2) == 0) {
-                return (e);
-            } else if ((SLOT_AMP_BITS - PG_BITS - 2) > 0) {
-                return ((e) >> (SLOT_AMP_BITS - PG_BITS - 2));
-            } else {
-                return ((e) << (2 + PG_BITS - SLOT_AMP_BITS));
-            }
-            */
-        }
-        /* Update AM, PM unit */
-        static void update_ampm(OPLL opll)
-        {
-            opll.pm_phase = (uint)((opll.pm_phase + pm_dphase) & (PM_DP_WIDTH - 1));
-            opll.am_phase = (int)((opll.am_phase + am_dphase) & (AM_DP_WIDTH - 1));
-            opll.lfo_am = amtable[HIGHBITS((uint)opll.am_phase, AM_DP_BITS - AM_PG_BITS)];
-            opll.lfo_pm = pmtable[HIGHBITS(opll.pm_phase, PM_DP_BITS - PM_PG_BITS)];
-        }
-
-        /* PG */
-        static void calc_phase(OPLL_SLOT slot, int lfo)
-        {
-            if (slot.patch.pm != 0)
-                slot.phase += (uint)((slot.dphase * lfo) >> PM_AMP_BITS);
-            else
-                slot.phase += slot.dphase;
-
-            slot.phase &= unchecked((uint)(DP_WIDTH - 1));
-
-            slot.pgout = HIGHBITS(slot.phase, DP_BASE_BITS);
-        }
-
-        /* Update Noise unit */
-        static void update_noise(OPLL opll)
-        {
-            if ((opll.noise_seed & 1) != 0) opll.noise_seed ^= 0x8003020;
-            opll.noise_seed >>= 1;
-        }
-
-        /* EG */
-        static uint S2E(double x) { return (SL2EG((uint)(x / SL_STEP)) << (EG_DP_BITS - EG_BITS)); }
-        static uint[] SL = new[] {
+			int tmp;
+			int fnum, block, TL, KL;
+
+			for (fnum = 0; fnum < 16; fnum++)
+				for (block = 0; block < 8; block++)
+					for (TL = 0; TL < 64; TL++)
+						for (KL = 0; KL < 4; KL++)
+						{
+							if (KL == 0)
+							{
+								tllTable[fnum, block, TL, KL] = TL2EG((uint)TL);
+							}
+							else
+							{
+								tmp = (int)(kltable[fnum] - dB2(3.000) * (7 - block));
+								if (tmp <= 0)
+									tllTable[fnum, block, TL, KL] = TL2EG((uint)TL);
+								else
+									tllTable[fnum, block, TL, KL] = (uint)((tmp >> (3 - KL)) / EG_STEP) + TL2EG((uint)TL);
+							}
+						}
+		}
+
+		/* Rate Table for Attack */
+		static void makeDphaseARTable()
+		{
+			int AR, Rks, RM, RL;
+
+			for (AR = 0; AR < 16; AR++)
+				for (Rks = 0; Rks < 16; Rks++)
+				{
+					RM = AR + (Rks >> 2);
+					RL = Rks & 3;
+					if (RM > 15)
+						RM = 15;
+					switch (AR)
+					{
+						case 0:
+							dphaseARTable[AR, Rks] = 0;
+							break;
+						case 15:
+							dphaseARTable[AR, Rks] = 0;/*EG_DP_WIDTH;*/
+							break;
+						default:
+							dphaseARTable[AR, Rks] = RATE_ADJUST((uint)((3 * (RL + 4) << (RM + 1))));
+							break;
+					}
+				}
+		}
+
+		/* Rate Table for Decay and Release */
+		static void makeDphaseDRTable()
+		{
+			int DR, Rks, RM, RL;
+
+			for (DR = 0; DR < 16; DR++)
+				for (Rks = 0; Rks < 16; Rks++)
+				{
+					RM = DR + (Rks >> 2);
+					RL = Rks & 3;
+					if (RM > 15)
+						RM = 15;
+					switch (DR)
+					{
+						case 0:
+							dphaseDRTable[DR, Rks] = 0;
+							break;
+						default:
+							dphaseDRTable[DR, Rks] = RATE_ADJUST((uint)((RL + 4) << (RM - 1)));
+							break;
+					}
+				}
+		}
+
+		static void makeRksTable()
+		{
+			int fnum8, block, KR;
+
+			for (fnum8 = 0; fnum8 < 2; fnum8++)
+				for (block = 0; block < 8; block++)
+					for (KR = 0; KR < 2; KR++)
+					{
+						if (KR != 0)
+							rksTable[fnum8, block, KR] = (block << 1) + fnum8;
+						else
+							rksTable[fnum8, block, KR] = block >> 1;
+					}
+		}
+
+		static void OPLL_dump2patch(byte[] dump, OPLL_PATCH[] patch)
+		{
+			patch[0].am = (uint)(dump[0] >> 7) & 1;
+			patch[1].am = (uint)(dump[1] >> 7) & 1;
+			patch[0].pm = (uint)(dump[0] >> 6) & 1;
+			patch[1].pm = (uint)(dump[1] >> 6) & 1;
+			patch[0].eg = (uint)(dump[0] >> 5) & 1;
+			patch[1].eg = (uint)(dump[1] >> 5) & 1;
+			patch[0].kr = (uint)(dump[0] >> 4) & 1;
+			patch[1].kr = (uint)(dump[1] >> 4) & 1;
+			patch[0].ml = (uint)(dump[0]) & 15;
+			patch[1].ml = (uint)(dump[1]) & 15;
+			patch[0].kl = (uint)(dump[2] >> 6) & 3;
+			patch[1].kl = (uint)(dump[3] >> 6) & 3;
+			patch[0].tl = (uint)(dump[2]) & 63;
+			patch[0].fb = (uint)(dump[3]) & 7;
+			patch[0].wf = (uint)(dump[3] >> 3) & 1;
+			patch[1].wf = (uint)(dump[3] >> 4) & 1;
+			patch[0].ar = (uint)(dump[4] >> 4) & 15;
+			patch[1].ar = (uint)(dump[5] >> 4) & 15;
+			patch[0].dr = (uint)(dump[4]) & 15;
+			patch[1].dr = (uint)(dump[5]) & 15;
+			patch[0].sl = (uint)(dump[6] >> 4) & 15;
+			patch[1].sl = (uint)(dump[7] >> 4) & 15;
+			patch[0].rr = (uint)(dump[6]) & 15;
+			patch[1].rr = (uint)(dump[7]) & 15;
+		}
+
+		static void
+		OPLL_getDefaultPatch(int type, int num, OPLL_PATCH[] patch)
+		{
+			byte[] r = new byte[8];
+			Array.Copy(default_inst[type], num * 16, r, 0, r.Length);
+			OPLL_dump2patch(r, patch);
+		}
+
+		static void makeDefaultPatch()
+		{
+			for (int i = 0; i < OPLL_TONE_NUM; i++)
+			{
+				for (int j = 0; j < 19; j++)
+				{
+					default_patch[i, j * 2 + 0] = new OPLL_PATCH();
+					default_patch[i, j * 2 + 1] = new OPLL_PATCH();
+					OPLL_getDefaultPatch(i, j, new[] { default_patch[i, j * 2 + 0], default_patch[i, j * 2 + 1] });
+				}
+			}
+		}
+
+		/************************************************************
+
+							  Calc Parameters
+
+		************************************************************/
+
+		static uint calc_eg_dphase(OPLL_SLOT slot)
+		{
+			switch (slot.eg_mode)
+			{
+				case OPLL_EG_STATE.ATTACK:
+					return dphaseARTable[slot.patch.ar, slot.rks];
+
+				case OPLL_EG_STATE.DECAY:
+					return dphaseDRTable[slot.patch.dr, slot.rks];
+
+				case OPLL_EG_STATE.SUSHOLD:
+					return 0;
+
+				case OPLL_EG_STATE.SUSTINE:
+					return dphaseDRTable[slot.patch.rr, slot.rks];
+
+				case OPLL_EG_STATE.RELEASE:
+					if (slot.sustine != 0)
+						return dphaseDRTable[5, slot.rks];
+					else if (slot.patch.eg != 0)
+						return dphaseDRTable[slot.patch.rr, slot.rks];
+					else
+						return dphaseDRTable[7, slot.rks];
+
+				case OPLL_EG_STATE.SETTLE:
+					return dphaseDRTable[15, 0];
+
+				case OPLL_EG_STATE.FINISH:
+					return 0;
+
+				default:
+					return 0;
+			}
+		}
+
+		/*************************************************************
+
+							OPLL public interfaces
+
+		*************************************************************/
+
+		const int SLOT_BD1 = 12;
+		const int SLOT_BD2 = 13;
+		const int SLOT_HH = 14;
+		const int SLOT_SD = 15;
+		const int SLOT_TOM = 16;
+		const int SLOT_CYM = 17;
+
+		static void UPDATE_PG(OPLL_SLOT S) { (S).dphase = dphaseTable[(S).fnum, (S).block, (S).patch.ml]; }
+		static void UPDATE_TLL(OPLL_SLOT S)
+		{
+			if (S.type == 0)
+			{
+				(S).tll = tllTable[((S).fnum) >> 5, (S).block, (S).patch.tl, (S).patch.kl];
+			}
+			else
+			{
+				(S).tll = tllTable[((S).fnum) >> 5, (S).block, (S).volume, (S).patch.kl];
+			}
+		}
+		static void UPDATE_RKS(OPLL_SLOT S) { (S).rks = (uint)rksTable[((S).fnum) >> 8, (S).block, (S).patch.kr]; }
+		static void UPDATE_WF(OPLL_SLOT S) { (S).sintbl = waveform[(S).patch.wf]; }
+		static void UPDATE_EG(OPLL_SLOT S) { (S).eg_dphase = calc_eg_dphase(S); }
+		static void UPDATE_ALL(OPLL_SLOT S)
+		{
+			UPDATE_PG(S);
+			UPDATE_TLL(S);
+			UPDATE_RKS(S);
+			UPDATE_WF(S);
+			UPDATE_EG(S);                  /* EG should be updated last. */
+		}
+
+		/* Slot key on  */
+		static void slotOn(OPLL_SLOT slot)
+		{
+			slot.eg_mode = OPLL_EG_STATE.ATTACK;
+			slot.eg_phase = 0;
+			slot.phase = 0;
+			UPDATE_EG(slot);
+		}
+
+		/* Slot key on without reseting the phase */
+		static void slotOn2(OPLL_SLOT slot)
+		{
+			slot.eg_mode = OPLL_EG_STATE.ATTACK;
+			slot.eg_phase = 0;
+			UPDATE_EG(slot);
+		}
+
+		/* Slot key off */
+		static void slotOff(OPLL_SLOT slot)
+		{
+			if (slot.eg_mode == OPLL_EG_STATE.ATTACK)
+				slot.eg_phase = (uint)EXPAND_BITS(AR_ADJUST_TABLE[HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS)], EG_BITS, EG_DP_BITS);
+			slot.eg_mode = OPLL_EG_STATE.RELEASE;
+			UPDATE_EG(slot);
+		}
+
+		/* Channel key on */
+		static void keyOn(OPLL opll, int i)
+		{
+			if (opll.slot_on_flag[i * 2] == 0)
+				slotOn(MOD(opll, i));
+			if (opll.slot_on_flag[i * 2 + 1] == 0)
+				slotOn(CAR(opll, i));
+			opll.key_status[i] = 1;
+		}
+
+		/* Channel key off */
+		static void keyOff(OPLL opll, int i)
+		{
+			if (opll.slot_on_flag[i * 2 + 1] != 0)
+				slotOff(CAR(opll, i));
+			opll.key_status[i] = 0;
+		}
+
+		static void keyOn_BD(OPLL opll)
+		{
+			keyOn(opll, 6);
+		}
+
+		static void keyOn_SD(OPLL opll)
+		{
+			if (opll.slot_on_flag[SLOT_SD] == 0)
+				slotOn(CAR(opll, 7));
+		}
+
+		static void keyOn_TOM(OPLL opll)
+		{
+			if (opll.slot_on_flag[SLOT_TOM] == 0)
+				slotOn(MOD(opll, 8));
+		}
+
+		static void keyOn_HH(OPLL opll)
+		{
+			if (opll.slot_on_flag[SLOT_HH] == 0)
+				slotOn2(MOD(opll, 7));
+		}
+
+		static void keyOn_CYM(OPLL opll)
+		{
+			if (opll.slot_on_flag[SLOT_CYM] == 0)
+				slotOn2(CAR(opll, 8));
+		}
+
+		/* Drum key off */
+		static void keyOff_BD(OPLL opll)
+		{
+			keyOff(opll, 6);
+		}
+
+		static void keyOff_SD(OPLL opll)
+		{
+			if (opll.slot_on_flag[SLOT_SD] == 0)
+				slotOff(CAR(opll, 7));
+		}
+
+		static void keyOff_TOM(OPLL opll)
+		{
+			if (opll.slot_on_flag[SLOT_TOM] != 0)
+				slotOff(MOD(opll, 8));
+		}
+
+		static void keyOff_HH(OPLL opll)
+		{
+			if (opll.slot_on_flag[SLOT_HH] != 0)
+				slotOff(MOD(opll, 7));
+		}
+
+		static void keyOff_CYM(OPLL opll)
+		{
+			if (opll.slot_on_flag[SLOT_CYM] != 0)
+				slotOff(CAR(opll, 8));
+		}
+
+		/* Change a voice */
+		static void setPatch(OPLL opll, int i, int num)
+		{
+			opll.patch_number[i] = num;
+			MOD(opll, i).patch = opll.patch[num * 2 + 0];
+			CAR(opll, i).patch = opll.patch[num * 2 + 1];
+		}
+
+		/* Change a rhythm voice */
+		static void setSlotPatch(OPLL_SLOT slot, OPLL_PATCH patch)
+		{
+			slot.patch = patch;
+		}
+
+		/* Set sustine parameter */
+		static void setSustine(OPLL opll, int c, int sustine)
+		{
+			CAR(opll, c).sustine = sustine;
+			if (MOD(opll, c).type != 0)
+				MOD(opll, c).sustine = sustine;
+		}
+
+		/* Volume : 6bit ( Volume register << 2 ) */
+		static void setVolume(OPLL opll, int c, int volume)
+		{
+			CAR(opll, c).volume = volume;
+		}
+
+		static void setSlotVolume(OPLL_SLOT slot, int volume)
+		{
+			slot.volume = volume;
+		}
+
+		/* Set F-Number ( fnum : 9bit ) */
+		static void setFnumber(OPLL opll, int c, int fnum)
+		{
+			CAR(opll, c).fnum = fnum;
+			MOD(opll, c).fnum = fnum;
+		}
+
+		/* Set Block data (block : 3bit ) */
+		static void setBlock(OPLL opll, int c, int block)
+		{
+			CAR(opll, c).block = block;
+			MOD(opll, c).block = block;
+		}
+
+		/* Change Rhythm Mode */
+		static void update_rhythm_mode(OPLL opll)
+		{
+			if ((opll.patch_number[6] & 0x10) != 0)
+			{
+				if ((opll.slot_on_flag[SLOT_BD2] | (opll.reg[0x0e] & 32)) == 0)
+				{
+					opll.slot[SLOT_BD1].eg_mode = OPLL_EG_STATE.FINISH;
+					opll.slot[SLOT_BD2].eg_mode = OPLL_EG_STATE.FINISH;
+					setPatch(opll, 6, opll.reg[0x36] >> 4);
+				}
+			}
+			else if ((opll.reg[0x0e] & 32) != 0)
+			{
+				opll.patch_number[6] = 16;
+				opll.slot[SLOT_BD1].eg_mode = OPLL_EG_STATE.FINISH;
+				opll.slot[SLOT_BD2].eg_mode = OPLL_EG_STATE.FINISH;
+				setSlotPatch(opll.slot[SLOT_BD1], opll.patch[16 * 2 + 0]);
+				setSlotPatch(opll.slot[SLOT_BD2], opll.patch[16 * 2 + 1]);
+			}
+
+			if ((opll.patch_number[7] & 0x10) != 0)
+			{
+				if (!((opll.slot_on_flag[SLOT_HH] != 0 && opll.slot_on_flag[SLOT_SD] != 0) | ((opll.reg[0x0e] & 32) != 0)))
+				{
+					opll.slot[SLOT_HH].type = 0;
+					opll.slot[SLOT_HH].eg_mode = OPLL_EG_STATE.FINISH;
+					opll.slot[SLOT_SD].eg_mode = OPLL_EG_STATE.FINISH;
+					setPatch(opll, 7, opll.reg[0x37] >> 4);
+				}
+			}
+			else if ((opll.reg[0x0e] & 32) != 0)
+			{
+				opll.patch_number[7] = 17;
+				opll.slot[SLOT_HH].type = 1;
+				opll.slot[SLOT_HH].eg_mode = OPLL_EG_STATE.FINISH;
+				opll.slot[SLOT_SD].eg_mode = OPLL_EG_STATE.FINISH;
+				setSlotPatch(opll.slot[SLOT_HH], opll.patch[17 * 2 + 0]);
+				setSlotPatch(opll.slot[SLOT_SD], opll.patch[17 * 2 + 1]);
+			}
+
+			if ((opll.patch_number[8] & 0x10) != 0)
+			{
+				if (!((opll.slot_on_flag[SLOT_CYM] != 0 && opll.slot_on_flag[SLOT_TOM] != 0) | ((opll.reg[0x0e] & 32) != 0)))
+				{
+					opll.slot[SLOT_TOM].type = 0;
+					opll.slot[SLOT_TOM].eg_mode = OPLL_EG_STATE.FINISH;
+					opll.slot[SLOT_CYM].eg_mode = OPLL_EG_STATE.FINISH;
+					setPatch(opll, 8, opll.reg[0x38] >> 4);
+				}
+			}
+			else if ((opll.reg[0x0e] & 32) != 0)
+			{
+				opll.patch_number[8] = 18;
+				opll.slot[SLOT_TOM].type = 1;
+				opll.slot[SLOT_TOM].eg_mode = OPLL_EG_STATE.FINISH;
+				opll.slot[SLOT_CYM].eg_mode = OPLL_EG_STATE.FINISH;
+				setSlotPatch(opll.slot[SLOT_TOM], opll.patch[18 * 2 + 0]);
+				setSlotPatch(opll.slot[SLOT_CYM], opll.patch[18 * 2 + 1]);
+			}
+		}
+
+		static void update_key_status(OPLL opll)
+		{
+			int ch;
+
+			for (ch = 0; ch < 9; ch++)
+				opll.slot_on_flag[ch * 2] = opll.slot_on_flag[ch * 2 + 1] = (opll.reg[0x20 + ch]) & 0x10;
+
+			if ((opll.reg[0x0e] & 32) != 0)
+			{
+				opll.slot_on_flag[SLOT_BD1] |= (opll.reg[0x0e] & 0x10);
+				opll.slot_on_flag[SLOT_BD2] |= (opll.reg[0x0e] & 0x10);
+				opll.slot_on_flag[SLOT_SD] |= (opll.reg[0x0e] & 0x08);
+				opll.slot_on_flag[SLOT_HH] |= (opll.reg[0x0e] & 0x01);
+				opll.slot_on_flag[SLOT_TOM] |= (opll.reg[0x0e] & 0x04);
+				opll.slot_on_flag[SLOT_CYM] |= (opll.reg[0x0e] & 0x02);
+			}
+		}
+
+		void OPLL_copyPatch(OPLL opll, int num, OPLL_PATCH patch)
+		{
+			opll.patch[num] = (OPLL_PATCH)patch.Clone();
+		}
+
+		/***********************************************************
+
+					  Initializing
+
+		***********************************************************/
+
+		static void OPLL_SLOT_reset(OPLL_SLOT slot, int type)
+		{
+			slot.type = type;
+			slot.sintbl = waveform[0];
+			slot.phase = 0;
+			slot.dphase = 0;
+			slot.output[0] = 0;
+			slot.output[1] = 0;
+			slot.feedback = 0;
+			slot.eg_mode = OPLL_EG_STATE.FINISH;
+			slot.eg_phase = EG_DP_WIDTH;
+			slot.eg_dphase = 0;
+			slot.rks = 0;
+			slot.tll = 0;
+			slot.sustine = 0;
+			slot.fnum = 0;
+			slot.block = 0;
+			slot.volume = 0;
+			slot.pgout = 0;
+			slot.egout = 0;
+			slot.patch = new OPLL_PATCH();
+		}
+
+		static void public_refresh()
+		{
+			makeDphaseTable();
+			makeDphaseARTable();
+			makeDphaseDRTable();
+			pm_dphase = (uint)RATE_ADJUST(PM_SPEED * PM_DP_WIDTH / (clk / 72));
+			am_dphase = (uint)RATE_ADJUST(AM_SPEED * AM_DP_WIDTH / (clk / 72));
+		}
+
+		static void maketables(uint c, uint r)
+		{
+			if (c != clk)
+			{
+				clk = c;
+				makePmTable();
+				makeAmTable();
+				makeDB2LinTable();
+				makeAdjustTable();
+				makeTllTable();
+				makeRksTable();
+				makeSinTable();
+				makeDefaultPatch();
+			}
+
+			if (r != rate)
+			{
+				rate = r;
+				public_refresh();
+			}
+		}
+
+		OPLL OPLL_new(uint clk, uint rate, int type)
+		{
+			OPLL opll = new OPLL();
+			int i;
+
+			maketables(clk, rate);
+
+			for (i = 0; i < 19 * 2; i++)
+				opll.patch[i] = new OPLL_PATCH();
+
+			opll.mask = 0;
+
+			OPLL_reset(opll);
+			OPLL_reset_patch(opll, type);
+
+			return opll;
+		}
+
+		/* Reset patch datas by system default. */
+		void OPLL_reset_patch(OPLL opll, int type)
+		{
+			int i;
+
+			for (i = 0; i < 19 * 2; i++)
+				OPLL_copyPatch(opll, i, default_patch[type % OPLL_TONE_NUM, i]);
+		}
+
+		/* Reset whole of OPLL except patch datas. */
+		void OPLL_reset(OPLL opll)
+		{
+			int i;
+
+			opll.adr = 0;
+			opll.output = 0;
+
+			opll.pm_phase = 0;
+			opll.am_phase = 0;
+
+			opll.noise_seed = 0xffff;
+			opll.mask = 0;
+
+			for (i = 0; i < 18; i++)
+				OPLL_SLOT_reset(opll.slot[i], i % 2);
+
+			for (i = 0; i < 9; i++)
+			{
+				opll.key_status[i] = 0;
+				setPatch(opll, i, 0);
+			}
+
+			for (i = 0; i < 0x40; i++)
+				OPLL_writeReg(opll, (uint)i, 0);
+
+			opll.realstep = (uint)((1 << 31) / rate);
+			opll.opllstep = (uint)((1 << 31) / (clk / 72));
+			opll.oplltime = 0;
+			for (i = 0; i < 14; i++)
+				opll.pan[i] = 3;
+			opll.sprev[0] = opll.sprev[1] = 0;
+			opll.snext[0] = opll.snext[1] = 0;
+
+		}
+
+		/* Force Refresh (When external program changes some parameters). */
+		void OPLL_forceRefresh(OPLL opll)
+		{
+			int i;
+
+			if (opll == null)
+				return;
+
+			for (i = 0; i < 9; i++)
+				setPatch(opll, i, opll.patch_number[i]);
+
+			for (i = 0; i < 18; i++)
+			{
+				UPDATE_PG(opll.slot[i]);
+				UPDATE_RKS(opll.slot[i]);
+				UPDATE_TLL(opll.slot[i]);
+				UPDATE_WF(opll.slot[i]);
+				UPDATE_EG(opll.slot[i]);
+			}
+		}
+
+		void OPLL_set_rate(OPLL opll, uint r)
+		{
+			if (opll.quality)
+				rate = 49716;
+			else
+				rate = r;
+			public_refresh();
+			rate = r;
+		}
+
+		void OPLL_set_quality(OPLL opll, bool q)
+		{
+			opll.quality = q;
+			OPLL_set_rate(opll, rate);
+		}
+
+		/*********************************************************
+
+				 Generate wave data
+
+		*********************************************************/
+
+		/* Convert Amp(0 to EG_HEIGHT) to Phase(0 to 2PI). */
+		static int wave2_2pi(int e)
+		{
+			return ((SLOT_AMP_BITS - PG_BITS) > 0) ?
+				((e) >> (SLOT_AMP_BITS - PG_BITS)) :
+				((e) << (PG_BITS - SLOT_AMP_BITS));
+		}
+
+		/* Convert Amp(0 to EG_HEIGHT) to Phase(0 to 4PI). */
+		static int wave2_4pi(int e)
+		{
+			return ((e) << (1 + PG_BITS - SLOT_AMP_BITS));
+			/*if ((SLOT_AMP_BITS - PG_BITS - 1) == 0) {
+				return (e);
+			} else if ((SLOT_AMP_BITS - PG_BITS - 1) > 0) {
+				return ((e) >> (SLOT_AMP_BITS - PG_BITS - 1));
+			} else {
+				return ((e) << (1 + PG_BITS - SLOT_AMP_BITS));
+			}*/
+		}
+		/* Convert Amp(0 to EG_HEIGHT) to Phase(0 to 8PI). */
+		static int wave2_8pi(int e)
+		{
+			return ((e) << (2 + PG_BITS - SLOT_AMP_BITS));
+			/*
+			if ((SLOT_AMP_BITS - PG_BITS - 2) == 0) {
+				return (e);
+			} else if ((SLOT_AMP_BITS - PG_BITS - 2) > 0) {
+				return ((e) >> (SLOT_AMP_BITS - PG_BITS - 2));
+			} else {
+				return ((e) << (2 + PG_BITS - SLOT_AMP_BITS));
+			}
+			*/
+		}
+		/* Update AM, PM unit */
+		static void update_ampm(OPLL opll)
+		{
+			opll.pm_phase = (uint)((opll.pm_phase + pm_dphase) & (PM_DP_WIDTH - 1));
+			opll.am_phase = (int)((opll.am_phase + am_dphase) & (AM_DP_WIDTH - 1));
+			opll.lfo_am = amtable[HIGHBITS((uint)opll.am_phase, AM_DP_BITS - AM_PG_BITS)];
+			opll.lfo_pm = pmtable[HIGHBITS(opll.pm_phase, PM_DP_BITS - PM_PG_BITS)];
+		}
+
+		/* PG */
+		static void calc_phase(OPLL_SLOT slot, int lfo)
+		{
+			if (slot.patch.pm != 0)
+				slot.phase += (uint)((slot.dphase * lfo) >> PM_AMP_BITS);
+			else
+				slot.phase += slot.dphase;
+
+			slot.phase &= unchecked((uint)(DP_WIDTH - 1));
+
+			slot.pgout = HIGHBITS(slot.phase, DP_BASE_BITS);
+		}
+
+		/* Update Noise unit */
+		static void update_noise(OPLL opll)
+		{
+			if ((opll.noise_seed & 1) != 0) opll.noise_seed ^= 0x8003020;
+			opll.noise_seed >>= 1;
+		}
+
+		/* EG */
+		static uint S2E(double x) { return (SL2EG((uint)(x / SL_STEP)) << (EG_DP_BITS - EG_BITS)); }
+		static uint[] SL = new[] {
 			    S2E (0.0), S2E (3.0), S2E (6.0), S2E (9.0), S2E (12.0), S2E (15.0), S2E (18.0), S2E (21.0),
 			    S2E (24.0), S2E (27.0), S2E (30.0), S2E (33.0), S2E (36.0), S2E (39.0), S2E (42.0), S2E (48.0)
 		    };
 
-        static void calc_envelope(OPLL_SLOT slot, int lfo)
-        {
-            uint egout;
-
-            switch (slot.eg_mode)
-            {
-                case OPLL_EG_STATE.ATTACK:
-                    egout = (uint)AR_ADJUST_TABLE[HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS)];
-                    slot.eg_phase += slot.eg_dphase;
-                    if ((EG_DP_WIDTH & slot.eg_phase) != 0 || (slot.patch.ar == 15))
-                    {
-                        egout = 0;
-                        slot.eg_phase = 0;
-                        slot.eg_mode = OPLL_EG_STATE.DECAY;
-                        UPDATE_EG(slot);
-                    }
-                    break;
-
-                case OPLL_EG_STATE.DECAY:
-                    egout = HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS);
-                    slot.eg_phase += slot.eg_dphase;
-                    if (slot.eg_phase >= SL[slot.patch.sl])
-                    {
-                        if (slot.patch.eg != 0)
-                        {
-                            slot.eg_phase = SL[slot.patch.sl];
-                            slot.eg_mode = OPLL_EG_STATE.SUSHOLD;
-                            UPDATE_EG(slot);
-                        }
-                        else
-                        {
-                            slot.eg_phase = SL[slot.patch.sl];
-                            slot.eg_mode = OPLL_EG_STATE.SUSTINE;
-                            UPDATE_EG(slot);
-                        }
-                    }
-                    break;
-
-                case OPLL_EG_STATE.SUSHOLD:
-                    egout = HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS);
-                    if (slot.patch.eg == 0)
-                    {
-                        slot.eg_mode = OPLL_EG_STATE.SUSTINE;
-                        UPDATE_EG(slot);
-                    }
-                    break;
-
-                case OPLL_EG_STATE.SUSTINE:
-                case OPLL_EG_STATE.RELEASE:
-                    egout = HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS);
-                    slot.eg_phase += slot.eg_dphase;
-                    if (egout >= (1 << EG_BITS))
-                    {
-                        slot.eg_mode = OPLL_EG_STATE.FINISH;
-                        egout = (1 << EG_BITS) - 1;
-                    }
-                    break;
-
-                case OPLL_EG_STATE.SETTLE:
-                    egout = HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS);
-                    slot.eg_phase += slot.eg_dphase;
-                    if (egout >= (1 << EG_BITS))
-                    {
-                        slot.eg_mode = OPLL_EG_STATE.ATTACK;
-                        egout = (1 << EG_BITS) - 1;
-                        UPDATE_EG(slot);
-                    }
-                    break;
-
-                case OPLL_EG_STATE.FINISH:
-                    egout = (1 << EG_BITS) - 1;
-                    break;
-
-                default:
-                    egout = (1 << EG_BITS) - 1;
-                    break;
-            }
-
-            if (slot.patch.am != 0)
-                egout = (uint)(EG2DB(egout + slot.tll) + lfo);
-            else
-                egout = EG2DB(egout + slot.tll);
-
-            if (egout >= DB_MUTE)
-                egout = unchecked((uint)DB_MUTE - 1);
-
-            slot.egout = egout | 3;
-        }
-
-        /* CARRIOR */
-        static int calc_slot_car(OPLL_SLOT slot, int fm)
-        {
-            if (slot.egout + 1 >= DB_MUTE)
-            {
-                slot.output[0] = 0;
-            }
-            else
-            {
-                slot.output[0] = DB2LIN_TABLE[slot.sintbl[(slot.pgout + wave2_8pi(fm)) & (PG_WIDTH - 1)] + slot.egout];
-            }
-            slot.output[1] = (slot.output[1] + slot.output[0]) >> 1;
-            return slot.output[1];
-        }
-
-        /* MODULATOR */
-        static int calc_slot_mod(OPLL_SLOT slot)
-        {
-            int fm;
-
-            slot.output[1] = slot.output[0];
-
-            if (slot.egout + 1 >= DB_MUTE)
-            {
-                slot.output[0] = 0;
-            }
-            else if (slot.patch.fb != 0)
-            {
-                fm = wave2_4pi(slot.feedback) >> (int)(7 - slot.patch.fb);
-                slot.output[0] = DB2LIN_TABLE[slot.sintbl[(slot.pgout + fm) & (PG_WIDTH - 1)] + slot.egout];
-            }
-            else
-            {
-                slot.output[0] = DB2LIN_TABLE[slot.sintbl[slot.pgout] + slot.egout];
-            }
-
-            slot.feedback = (slot.output[1] + slot.output[0]) >> 1;
-
-            return slot.feedback;
-        }
-
-        /* TOM */
-        static int calc_slot_tom(OPLL_SLOT slot)
-        {
-            if (slot.egout + 1 >= DB_MUTE)
-                return 0;
-
-            return DB2LIN_TABLE[slot.sintbl[slot.pgout] + slot.egout];
-        }
-
-        /* SNARE */
-        static int calc_slot_snare(OPLL_SLOT slot, uint noise)
-        {
-            if (slot.egout + 1 >= DB_MUTE)
-                return 0;
-
-            if (BIT(slot.pgout, 7))
-                return DB2LIN_TABLE[(noise != 0 ? DB_POS(0.0) : DB_POS(15.0)) + slot.egout];
-            else
-                return DB2LIN_TABLE[(noise != 0 ? DB_NEG(0.0) : DB_NEG(15.0)) + slot.egout];
-        }
-
-        /* 
-          TOP-CYM 
-         */
-        static int calc_slot_cym(OPLL_SLOT slot, uint pgout_hh)
-        {
-            uint dbout;
-            if (slot.egout + 1 >= DB_MUTE)
-                return 0;
-            else if (
-                /* the same as fmopl.c */
-                ((BIT(pgout_hh, PG_BITS - 8) ^ BIT(pgout_hh, PG_BITS - 1)) | BIT(pgout_hh, PG_BITS - 7)) ^
-                /* different from fmopl.c */
-               (BIT(slot.pgout, PG_BITS - 7) & !BIT(slot.pgout, PG_BITS - 5))
-              )
-                dbout = DB_NEG(3.0);
-            else
-                dbout = DB_POS(3.0);
-
-            return DB2LIN_TABLE[dbout + slot.egout];
-        }
-
-        /* 
-          HI-HAT 
-        */
-        static int calc_slot_hat(OPLL_SLOT slot, int pgout_cym, uint noise)
-        {
-            uint dbout;
-
-            if (slot.egout + 1 >= DB_MUTE)
-                return 0;
-            else if (
-                /* the same as fmopl.c */
-                ((BIT(slot.pgout, PG_BITS - 8) ^ BIT(slot.pgout, PG_BITS - 1)) | BIT(slot.pgout, PG_BITS - 7)) ^
-                /* different from fmopl.c */
-                (BIT(pgout_cym, PG_BITS - 7) & !BIT(pgout_cym, PG_BITS - 5))
-              )
-            {
-                if (noise != 0)
-                    dbout = DB_NEG(12.0);
-                else
-                    dbout = DB_NEG(24.0);
-            }
-            else
-            {
-                if (noise != 0)
-                    dbout = DB_POS(12.0);
-                else
-                    dbout = DB_POS(24.0);
-            }
-
-            return DB2LIN_TABLE[dbout + slot.egout];
-        }
-
-        static short calc(OPLL opll)
-        {
-            int inst = 0, perc = 0, output = 0;
-            int i;
-
-            update_ampm(opll);
-            update_noise(opll);
-
-            for (i = 0; i < 18; i++)
-            {
-                calc_phase(opll.slot[i], opll.lfo_pm);
-                calc_envelope(opll.slot[i], opll.lfo_am);
-            }
-
-            for (i = 0; i < 6; i++)
-                if ((opll.mask & OPLL_MASK_CH(i)) == 0 && (CAR(opll, i).eg_mode != OPLL_EG_STATE.FINISH))
-                    inst += calc_slot_car(CAR(opll, i), calc_slot_mod(MOD(opll, i)));
-
-            /* CH6 */
-            if (opll.patch_number[6] <= 15)
-            {
-                if ((opll.mask & OPLL_MASK_CH(6)) == 0 && (CAR(opll, 6).eg_mode != OPLL_EG_STATE.FINISH))
-                    inst += calc_slot_car(CAR(opll, 6), calc_slot_mod(MOD(opll, 6)));
-            }
-            else
-            {
-                if ((opll.mask & OPLL_MASK_BD) == 0 && (CAR(opll, 6).eg_mode != OPLL_EG_STATE.FINISH))
-                    perc += calc_slot_car(CAR(opll, 6), calc_slot_mod(MOD(opll, 6)));
-            }
-
-            /* CH7 */
-            if (opll.patch_number[7] <= 15)
-            {
-                if ((opll.mask & OPLL_MASK_CH(7)) == 0 && (CAR(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
-                    inst += calc_slot_car(CAR(opll, 7), calc_slot_mod(MOD(opll, 7)));
-            }
-            else
-            {
-                if ((opll.mask & OPLL_MASK_HH) == 0 && (MOD(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
-                    perc += calc_slot_hat(MOD(opll, 7), (int)CAR(opll, 8).pgout, opll.noise_seed & 1);
-                if ((opll.mask & OPLL_MASK_SD) == 0 && (CAR(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
-                    perc -= calc_slot_snare(CAR(opll, 7), opll.noise_seed & 1);
-            }
-
-            /* CH8 */
-            if (opll.patch_number[8] <= 15)
-            {
-                if ((opll.mask & OPLL_MASK_CH(8)) == 0 && (CAR(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
-                    inst += calc_slot_car(CAR(opll, 8), calc_slot_mod(MOD(opll, 8)));
-            }
-            else
-            {
-                if ((opll.mask & OPLL_MASK_TOM) == 0 && (MOD(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
-                    perc += calc_slot_tom(MOD(opll, 8));
-                if ((opll.mask & OPLL_MASK_CYM) == 0 && (CAR(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
-                    perc -= calc_slot_cym(CAR(opll, 8), MOD(opll, 7).pgout);
-            }
-
-            output = inst + (perc << 1);
-            return (short)(output << 3);
-        }
-
-        short OPLL_calc(OPLL opll)
-        {
-            if (!opll.quality)
-                return calc(opll);
-
-            while (opll.realstep > opll.oplltime)
-            {
-                opll.oplltime += opll.opllstep;
-                opll.prev = opll.next;
-                opll.next = calc(opll);
-            }
-
-            opll.oplltime -= opll.realstep;
-            opll.output = (short)(((double)opll.next * (opll.opllstep - opll.oplltime)
-                                    + (double)opll.prev * opll.oplltime) / opll.opllstep);
-            return (short)opll.output;
-        }
-
-        uint OPLL_setMask(OPLL opll, uint mask)
-        {
-            uint ret;
-
-            if (opll != null)
-            {
-                ret = opll.mask;
-                opll.mask = mask;
-                return ret;
-            }
-            else
-                return 0;
-        }
-
-        uint OPLL_toggleMask(OPLL opll, uint mask)
-        {
-            uint ret;
-
-            if (opll != null)
-            {
-                ret = opll.mask;
-                opll.mask ^= mask;
-                return ret;
-            }
-            else
-                return 0;
-        }
-
-        /****************************************************
-
-                               I/O Ctrl
-
-        *****************************************************/
-
-        void OPLL_writeReg(OPLL opll, uint reg, uint data)
-        {
-            int i, v, ch;
-
-            data = data & 0xff;
-            reg = reg & 0x3f;
-            opll.reg[reg] = (byte)data;
-
-            switch (reg)
-            {
-                case 0x00:
-                    opll.patch[0].am = (data >> 7) & 1;
-                    opll.patch[0].pm = (data >> 6) & 1;
-                    opll.patch[0].eg = (data >> 5) & 1;
-                    opll.patch[0].kr = (data >> 4) & 1;
-                    opll.patch[0].ml = (data) & 15;
-                    for (i = 0; i < 9; i++)
-                    {
-                        if (opll.patch_number[i] == 0)
-                        {
-                            UPDATE_PG(MOD(opll, i));
-                            UPDATE_RKS(MOD(opll, i));
-                            UPDATE_EG(MOD(opll, i));
-                        }
-                    }
-                    break;
-
-                case 0x01:
-                    opll.patch[1].am = (data >> 7) & 1;
-                    opll.patch[1].pm = (data >> 6) & 1;
-                    opll.patch[1].eg = (data >> 5) & 1;
-                    opll.patch[1].kr = (data >> 4) & 1;
-                    opll.patch[1].ml = (data) & 15;
-                    for (i = 0; i < 9; i++)
-                    {
-                        if (opll.patch_number[i] == 0)
-                        {
-                            UPDATE_PG(CAR(opll, i));
-                            UPDATE_RKS(CAR(opll, i));
-                            UPDATE_EG(CAR(opll, i));
-                        }
-                    }
-                    break;
-
-                case 0x02:
-                    opll.patch[0].kl = (data >> 6) & 3;
-                    opll.patch[0].tl = (data) & 63;
-                    for (i = 0; i < 9; i++)
-                    {
-                        if (opll.patch_number[i] == 0)
-                        {
-                            UPDATE_TLL(MOD(opll, i));
-                        }
-                    }
-                    break;
-
-                case 0x03:
-                    opll.patch[1].kl = (data >> 6) & 3;
-                    opll.patch[1].wf = (data >> 4) & 1;
-                    opll.patch[0].wf = (data >> 3) & 1;
-                    opll.patch[0].fb = (data) & 7;
-                    for (i = 0; i < 9; i++)
-                    {
-                        if (opll.patch_number[i] == 0)
-                        {
-                            UPDATE_WF(MOD(opll, i));
-                            UPDATE_WF(CAR(opll, i));
-                        }
-                    }
-                    break;
-
-                case 0x04:
-                    opll.patch[0].ar = (data >> 4) & 15;
-                    opll.patch[0].dr = (data) & 15;
-                    for (i = 0; i < 9; i++)
-                    {
-                        if (opll.patch_number[i] == 0)
-                        {
-                            UPDATE_EG(MOD(opll, i));
-                        }
-                    }
-                    break;
-
-                case 0x05:
-                    opll.patch[1].ar = (data >> 4) & 15;
-                    opll.patch[1].dr = (data) & 15;
-                    for (i = 0; i < 9; i++)
-                    {
-                        if (opll.patch_number[i] == 0)
-                        {
-                            UPDATE_EG(CAR(opll, i));
-                        }
-                    }
-                    break;
-
-                case 0x06:
-                    opll.patch[0].sl = (data >> 4) & 15;
-                    opll.patch[0].rr = (data) & 15;
-                    for (i = 0; i < 9; i++)
-                    {
-                        if (opll.patch_number[i] == 0)
-                        {
-                            UPDATE_EG(MOD(opll, i));
-                        }
-                    }
-                    break;
-
-                case 0x07:
-                    opll.patch[1].sl = (data >> 4) & 15;
-                    opll.patch[1].rr = (data) & 15;
-                    for (i = 0; i < 9; i++)
-                    {
-                        if (opll.patch_number[i] == 0)
-                        {
-                            UPDATE_EG(CAR(opll, i));
-                        }
-                    }
-                    break;
-
-                case 0x0e:
-                    update_rhythm_mode(opll);
-                    if ((data & 32) != 0)
-                    {
-                        if ((data & 0x10) != 0)
-                            keyOn_BD(opll);
-                        else
-                            keyOff_BD(opll);
-                        if ((data & 0x8) != 0)
-                            keyOn_SD(opll);
-                        else
-                            keyOff_SD(opll);
-                        if ((data & 0x4) != 0)
-                            keyOn_TOM(opll);
-                        else
-                            keyOff_TOM(opll);
-                        if ((data & 0x2) != 0)
-                            keyOn_CYM(opll);
-                        else
-                            keyOff_CYM(opll);
-                        if ((data & 0x1) != 0)
-                            keyOn_HH(opll);
-                        else
-                            keyOff_HH(opll);
-                    }
-                    update_key_status(opll);
-
-                    UPDATE_ALL(MOD(opll, 6));
-                    UPDATE_ALL(CAR(opll, 6));
-                    UPDATE_ALL(MOD(opll, 7));
-                    UPDATE_ALL(CAR(opll, 7));
-                    UPDATE_ALL(MOD(opll, 8));
-                    UPDATE_ALL(CAR(opll, 8));
-
-                    break;
-
-                case 0x0f:
-                    break;
-
-                case 0x10:
-                case 0x11:
-                case 0x12:
-                case 0x13:
-                case 0x14:
-                case 0x15:
-                case 0x16:
-                case 0x17:
-                case 0x18:
-                    ch = (int)(reg - 0x10);
-                    setFnumber(opll, ch, (int)data + ((opll.reg[0x20 + ch] & 1) << 8));
-                    UPDATE_ALL(MOD(opll, ch));
-                    UPDATE_ALL(CAR(opll, ch));
-                    break;
-
-                case 0x20:
-                case 0x21:
-                case 0x22:
-                case 0x23:
-                case 0x24:
-                case 0x25:
-                case 0x26:
-                case 0x27:
-                case 0x28:
-                    ch = (int)(reg - 0x20);
-                    setFnumber(opll, ch, (int)((data & 1) << 8) + opll.reg[0x10 + ch]);
-                    setBlock(opll, ch, (int)(data >> 1) & 7);
-                    setSustine(opll, ch, (int)(data >> 5) & 1);
-                    if ((data & 0x10) != 0)
-                        keyOn(opll, ch);
-                    else
-                        keyOff(opll, ch);
-                    UPDATE_ALL(MOD(opll, ch));
-                    UPDATE_ALL(CAR(opll, ch));
-                    update_key_status(opll);
-                    update_rhythm_mode(opll);
-                    break;
-
-                case 0x30:
-                case 0x31:
-                case 0x32:
-                case 0x33:
-                case 0x34:
-                case 0x35:
-                case 0x36:
-                case 0x37:
-                case 0x38:
-                    i = (int)((data >> 4) & 15);
-                    v = (int)(data & 15);
-                    if ((opll.reg[0x0e] & 32) != 0 && (reg >= 0x36))
-                    {
-                        switch (reg)
-                        {
-                            case 0x37:
-                                setSlotVolume(MOD(opll, 7), i << 2);
-                                break;
-                            case 0x38:
-                                setSlotVolume(MOD(opll, 8), i << 2);
-                                break;
-                            default:
-                                break;
-                        }
-                    }
-                    else
-                    {
-                        setPatch(opll, (int)(reg - 0x30), i);
-                    }
-                    setVolume(opll, (int)(reg - 0x30), v << 2);
-                    UPDATE_ALL(MOD(opll, (int)(reg - 0x30)));
-                    UPDATE_ALL(CAR(opll, (int)(reg - 0x30)));
-                    break;
-
-                default:
-                    break;
-
-            }
-        }
-
-        void OPLL_writeIO(OPLL opll, uint adr, uint val)
-        {
-            if ((adr & 1) != 0)
-                OPLL_writeReg(opll, opll.adr, val);
-            else
-                opll.adr = val;
-        }
-
-        /* STEREO MODE (OPT) */
-        void OPLL_set_pan(OPLL opll, uint ch, uint pan)
-        {
-            opll.pan[ch & 15] = pan & 3;
-        }
-
-        static void calc_stereo(OPLL opll, int[] output)
-        {
-            int[] b = new[] { 0, 0, 0, 0 };        /* Ignore, Right, Left, Center */
-            int[] r = new[] { 0, 0, 0, 0 };        /* Ignore, Right, Left, Center */
-            int i;
-
-            update_ampm(opll);
-            update_noise(opll);
-
-            for (i = 0; i < 18; i++)
-            {
-                calc_phase(opll.slot[i], opll.lfo_pm);
-                calc_envelope(opll.slot[i], opll.lfo_am);
-            }
-
-            for (i = 0; i < 6; i++)
-                if ((opll.mask & OPLL_MASK_CH(i)) == 0 && (CAR(opll, i).eg_mode != OPLL_EG_STATE.FINISH))
-                    b[opll.pan[i]] += calc_slot_car(CAR(opll, i), calc_slot_mod(MOD(opll, i)));
-
-
-            if (opll.patch_number[6] <= 15)
-            {
-                if ((opll.mask & OPLL_MASK_CH(6)) == 0 && (CAR(opll, 6).eg_mode != OPLL_EG_STATE.FINISH))
-                    b[opll.pan[6]] += calc_slot_car(CAR(opll, 6), calc_slot_mod(MOD(opll, 6)));
-            }
-            else
-            {
-                if ((opll.mask & OPLL_MASK_BD) == 0 && (CAR(opll, 6).eg_mode != OPLL_EG_STATE.FINISH))
-                    r[opll.pan[9]] += calc_slot_car(CAR(opll, 6), calc_slot_mod(MOD(opll, 6)));
-            }
-
-            if (opll.patch_number[7] <= 15)
-            {
-                if ((opll.mask & OPLL_MASK_CH(7)) == 0 && (CAR(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
-                    b[opll.pan[7]] += calc_slot_car(CAR(opll, 7), calc_slot_mod(MOD(opll, 7)));
-            }
-            else
-            {
-                if ((opll.mask & OPLL_MASK_HH) == 0 && (MOD(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
-                    r[opll.pan[10]] += calc_slot_hat(MOD(opll, 7), (int)CAR(opll, 8).pgout, opll.noise_seed & 1);
-                if ((opll.mask & OPLL_MASK_SD) == 0 && (CAR(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
-                    r[opll.pan[11]] -= calc_slot_snare(CAR(opll, 7), opll.noise_seed & 1);
-            }
-
-            if (opll.patch_number[8] <= 15)
-            {
-                if ((opll.mask & OPLL_MASK_CH(8)) == 0 && (CAR(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
-                    b[opll.pan[8]] += calc_slot_car(CAR(opll, 8), calc_slot_mod(MOD(opll, 8)));
-            }
-            else
-            {
-                if ((opll.mask & OPLL_MASK_TOM) == 0 && (MOD(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
-                    r[opll.pan[12]] += calc_slot_tom(MOD(opll, 8));
-                if ((opll.mask & OPLL_MASK_CYM) == 0 && (CAR(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
-                    r[opll.pan[13]] -= calc_slot_cym(CAR(opll, 8), MOD(opll, 7).pgout);
-            }
-
-            output[1] = (b[1] + b[3] + ((r[1] + r[3]) << 1)) << 3;
-            output[0] = (b[2] + b[3] + ((r[2] + r[3]) << 1)) << 3;
-        }
-
-        void OPLL_calc_stereo(OPLL opll, int[] output)
-        {
-            if (!opll.quality)
-            {
-                calc_stereo(opll, output);
-                return;
-            }
-
-            while (opll.realstep > opll.oplltime)
-            {
-                opll.oplltime += opll.opllstep;
-                opll.sprev[0] = opll.snext[0];
-                opll.sprev[1] = opll.snext[1];
-                calc_stereo(opll, opll.snext);
-            }
-
-            opll.oplltime -= opll.realstep;
-            output[0] = (short)(((double)opll.snext[0] * (opll.opllstep - opll.oplltime)
-                                 + (double)opll.sprev[0] * opll.oplltime) / opll.opllstep);
-            output[1] = (short)(((double)opll.snext[1] * (opll.opllstep - opll.oplltime)
-                                 + (double)opll.sprev[1] * opll.oplltime) / opll.opllstep);
-        }
-
-        /* voice data */
-        public sealed class OPLL_PATCH : ICloneable
-        {
-            public uint tl, fb, eg, ml, ar, dr, sl, rr, kr, kl, am, pm, wf;
-
-            public object Clone()
-            {
-                OPLL_PATCH o = new OPLL_PATCH();
-                o.tl = this.tl; o.fb = this.fb; o.eg = this.eg; o.ml = this.ml; o.ar = this.ar; o.dr = this.dr; o.sl = this.sl; o.rr = this.rr; o.kr = this.kr; o.kl = this.kl; o.am = this.am; o.pm = this.pm; o.wf = this.wf;
-                return o;
-            }
-        }
-
-        /* slot */
-        public sealed class OPLL_SLOT
-        {
-            public OPLL_PATCH patch;
-
-            public int type;          /* 0 : modulator 1 : carrier */
-
-            /* OUTPUT */
-            public int feedback;
-
-            public int[] output = new int[2];   /* Output value of slot */
-
-            /* for Phase Generator (PG) */
-            public short[] sintbl;   /* Wavetable */
-            public uint phase;      /* Phase */
-            public uint dphase;     /* Phase increment amount */
-            public uint pgout;      /* output */
-
-            /* for Envelope Generator (EG) */
-            public int fnum;          /* F-Number */
-            public int block;         /* Block */
-            public int volume;        /* Current volume */
-            public int sustine;       /* Sustine 1 = ON, 0 = OFF */
-            public uint tll;	      /* Total Level + Key scale level*/
-            public uint rks;        /* Key scale offset (Rks) */
-            public OPLL_EG_STATE eg_mode;       /* Current state */
-            public uint eg_phase;   /* Phase */
-            public uint eg_dphase;  /* Phase increment amount */
-            public uint egout;      /* output */
-
-        }
-
-        public sealed class OPLL
-        {
-            public uint adr;
-            public int output;
-
-            public uint realstep;
-            public uint oplltime;
-            public uint opllstep;
-            public int prev, next;
-            public int[] sprev = new int[2], snext = new int[2];
-            public uint[] pan = new uint[16];
-
-            /* Register */
-            public byte[] reg = new byte[0x40];
-            public int[] slot_on_flag = new int[18];
-
-            /* Pitch Modulator */
-            public uint pm_phase;
-            public int lfo_pm;
-
-            /* Amp Modulator */
-            public int am_phase;
-            public int lfo_am;
-
-            public bool quality;
-
-            /* Noise Generator */
-            public uint noise_seed;
-
-            /* Channel Data */
-            public int[] patch_number = new int[9];
-            public int[] key_status = new int[9];
-
-            /* Slot */
-            public OPLL_SLOT[] slot = new OPLL_SLOT[18];
-
-            /* Voice Data */
-            public OPLL_PATCH[] patch = new OPLL_PATCH[19 * 2];
-            public int[] patch_update = new int[2]; /* flag for check patch update */
-
-            public uint mask;
-
-            public OPLL()
-            {
-                for (int i = 0; i < this.slot.Length; ++i) this.slot[i] = new OPLL_SLOT();
-                for (int i = 0; i < this.patch.Length; i++) this.patch[i] = new OPLL_PATCH();
-            }
-
-        }
-
-        #endregion
-    }
+		static void calc_envelope(OPLL_SLOT slot, int lfo)
+		{
+			uint egout;
+
+			switch (slot.eg_mode)
+			{
+				case OPLL_EG_STATE.ATTACK:
+					egout = (uint)AR_ADJUST_TABLE[HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS)];
+					slot.eg_phase += slot.eg_dphase;
+					if ((EG_DP_WIDTH & slot.eg_phase) != 0 || (slot.patch.ar == 15))
+					{
+						egout = 0;
+						slot.eg_phase = 0;
+						slot.eg_mode = OPLL_EG_STATE.DECAY;
+						UPDATE_EG(slot);
+					}
+					break;
+
+				case OPLL_EG_STATE.DECAY:
+					egout = HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS);
+					slot.eg_phase += slot.eg_dphase;
+					if (slot.eg_phase >= SL[slot.patch.sl])
+					{
+						if (slot.patch.eg != 0)
+						{
+							slot.eg_phase = SL[slot.patch.sl];
+							slot.eg_mode = OPLL_EG_STATE.SUSHOLD;
+							UPDATE_EG(slot);
+						}
+						else
+						{
+							slot.eg_phase = SL[slot.patch.sl];
+							slot.eg_mode = OPLL_EG_STATE.SUSTINE;
+							UPDATE_EG(slot);
+						}
+					}
+					break;
+
+				case OPLL_EG_STATE.SUSHOLD:
+					egout = HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS);
+					if (slot.patch.eg == 0)
+					{
+						slot.eg_mode = OPLL_EG_STATE.SUSTINE;
+						UPDATE_EG(slot);
+					}
+					break;
+
+				case OPLL_EG_STATE.SUSTINE:
+				case OPLL_EG_STATE.RELEASE:
+					egout = HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS);
+					slot.eg_phase += slot.eg_dphase;
+					if (egout >= (1 << EG_BITS))
+					{
+						slot.eg_mode = OPLL_EG_STATE.FINISH;
+						egout = (1 << EG_BITS) - 1;
+					}
+					break;
+
+				case OPLL_EG_STATE.SETTLE:
+					egout = HIGHBITS(slot.eg_phase, EG_DP_BITS - EG_BITS);
+					slot.eg_phase += slot.eg_dphase;
+					if (egout >= (1 << EG_BITS))
+					{
+						slot.eg_mode = OPLL_EG_STATE.ATTACK;
+						egout = (1 << EG_BITS) - 1;
+						UPDATE_EG(slot);
+					}
+					break;
+
+				case OPLL_EG_STATE.FINISH:
+					egout = (1 << EG_BITS) - 1;
+					break;
+
+				default:
+					egout = (1 << EG_BITS) - 1;
+					break;
+			}
+
+			if (slot.patch.am != 0)
+				egout = (uint)(EG2DB(egout + slot.tll) + lfo);
+			else
+				egout = EG2DB(egout + slot.tll);
+
+			if (egout >= DB_MUTE)
+				egout = unchecked((uint)DB_MUTE - 1);
+
+			slot.egout = egout | 3;
+		}
+
+		/* CARRIOR */
+		static int calc_slot_car(OPLL_SLOT slot, int fm)
+		{
+			if (slot.egout + 1 >= DB_MUTE)
+			{
+				slot.output[0] = 0;
+			}
+			else
+			{
+				slot.output[0] = DB2LIN_TABLE[slot.sintbl[(slot.pgout + wave2_8pi(fm)) & (PG_WIDTH - 1)] + slot.egout];
+			}
+			slot.output[1] = (slot.output[1] + slot.output[0]) >> 1;
+			return slot.output[1];
+		}
+
+		/* MODULATOR */
+		static int calc_slot_mod(OPLL_SLOT slot)
+		{
+			int fm;
+
+			slot.output[1] = slot.output[0];
+
+			if (slot.egout + 1 >= DB_MUTE)
+			{
+				slot.output[0] = 0;
+			}
+			else if (slot.patch.fb != 0)
+			{
+				fm = wave2_4pi(slot.feedback) >> (int)(7 - slot.patch.fb);
+				slot.output[0] = DB2LIN_TABLE[slot.sintbl[(slot.pgout + fm) & (PG_WIDTH - 1)] + slot.egout];
+			}
+			else
+			{
+				slot.output[0] = DB2LIN_TABLE[slot.sintbl[slot.pgout] + slot.egout];
+			}
+
+			slot.feedback = (slot.output[1] + slot.output[0]) >> 1;
+
+			return slot.feedback;
+		}
+
+		/* TOM */
+		static int calc_slot_tom(OPLL_SLOT slot)
+		{
+			if (slot.egout + 1 >= DB_MUTE)
+				return 0;
+
+			return DB2LIN_TABLE[slot.sintbl[slot.pgout] + slot.egout];
+		}
+
+		/* SNARE */
+		static int calc_slot_snare(OPLL_SLOT slot, uint noise)
+		{
+			if (slot.egout + 1 >= DB_MUTE)
+				return 0;
+
+			if (BIT(slot.pgout, 7))
+				return DB2LIN_TABLE[(noise != 0 ? DB_POS(0.0) : DB_POS(15.0)) + slot.egout];
+			else
+				return DB2LIN_TABLE[(noise != 0 ? DB_NEG(0.0) : DB_NEG(15.0)) + slot.egout];
+		}
+
+		/* 
+		  TOP-CYM 
+		 */
+		static int calc_slot_cym(OPLL_SLOT slot, uint pgout_hh)
+		{
+			uint dbout;
+			if (slot.egout + 1 >= DB_MUTE)
+				return 0;
+			else if (
+				/* the same as fmopl.c */
+				((BIT(pgout_hh, PG_BITS - 8) ^ BIT(pgout_hh, PG_BITS - 1)) | BIT(pgout_hh, PG_BITS - 7)) ^
+				/* different from fmopl.c */
+			   (BIT(slot.pgout, PG_BITS - 7) & !BIT(slot.pgout, PG_BITS - 5))
+			  )
+				dbout = DB_NEG(3.0);
+			else
+				dbout = DB_POS(3.0);
+
+			return DB2LIN_TABLE[dbout + slot.egout];
+		}
+
+		/* 
+		  HI-HAT 
+		*/
+		static int calc_slot_hat(OPLL_SLOT slot, int pgout_cym, uint noise)
+		{
+			uint dbout;
+
+			if (slot.egout + 1 >= DB_MUTE)
+				return 0;
+			else if (
+				/* the same as fmopl.c */
+				((BIT(slot.pgout, PG_BITS - 8) ^ BIT(slot.pgout, PG_BITS - 1)) | BIT(slot.pgout, PG_BITS - 7)) ^
+				/* different from fmopl.c */
+				(BIT(pgout_cym, PG_BITS - 7) & !BIT(pgout_cym, PG_BITS - 5))
+			  )
+			{
+				if (noise != 0)
+					dbout = DB_NEG(12.0);
+				else
+					dbout = DB_NEG(24.0);
+			}
+			else
+			{
+				if (noise != 0)
+					dbout = DB_POS(12.0);
+				else
+					dbout = DB_POS(24.0);
+			}
+
+			return DB2LIN_TABLE[dbout + slot.egout];
+		}
+
+		static short calc(OPLL opll)
+		{
+			int inst = 0, perc = 0, output = 0;
+			int i;
+
+			update_ampm(opll);
+			update_noise(opll);
+
+			for (i = 0; i < 18; i++)
+			{
+				calc_phase(opll.slot[i], opll.lfo_pm);
+				calc_envelope(opll.slot[i], opll.lfo_am);
+			}
+
+			for (i = 0; i < 6; i++)
+				if ((opll.mask & OPLL_MASK_CH(i)) == 0 && (CAR(opll, i).eg_mode != OPLL_EG_STATE.FINISH))
+					inst += calc_slot_car(CAR(opll, i), calc_slot_mod(MOD(opll, i)));
+
+			/* CH6 */
+			if (opll.patch_number[6] <= 15)
+			{
+				if ((opll.mask & OPLL_MASK_CH(6)) == 0 && (CAR(opll, 6).eg_mode != OPLL_EG_STATE.FINISH))
+					inst += calc_slot_car(CAR(opll, 6), calc_slot_mod(MOD(opll, 6)));
+			}
+			else
+			{
+				if ((opll.mask & OPLL_MASK_BD) == 0 && (CAR(opll, 6).eg_mode != OPLL_EG_STATE.FINISH))
+					perc += calc_slot_car(CAR(opll, 6), calc_slot_mod(MOD(opll, 6)));
+			}
+
+			/* CH7 */
+			if (opll.patch_number[7] <= 15)
+			{
+				if ((opll.mask & OPLL_MASK_CH(7)) == 0 && (CAR(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
+					inst += calc_slot_car(CAR(opll, 7), calc_slot_mod(MOD(opll, 7)));
+			}
+			else
+			{
+				if ((opll.mask & OPLL_MASK_HH) == 0 && (MOD(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
+					perc += calc_slot_hat(MOD(opll, 7), (int)CAR(opll, 8).pgout, opll.noise_seed & 1);
+				if ((opll.mask & OPLL_MASK_SD) == 0 && (CAR(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
+					perc -= calc_slot_snare(CAR(opll, 7), opll.noise_seed & 1);
+			}
+
+			/* CH8 */
+			if (opll.patch_number[8] <= 15)
+			{
+				if ((opll.mask & OPLL_MASK_CH(8)) == 0 && (CAR(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
+					inst += calc_slot_car(CAR(opll, 8), calc_slot_mod(MOD(opll, 8)));
+			}
+			else
+			{
+				if ((opll.mask & OPLL_MASK_TOM) == 0 && (MOD(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
+					perc += calc_slot_tom(MOD(opll, 8));
+				if ((opll.mask & OPLL_MASK_CYM) == 0 && (CAR(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
+					perc -= calc_slot_cym(CAR(opll, 8), MOD(opll, 7).pgout);
+			}
+
+			output = inst + (perc << 1);
+			return (short)(output << 3);
+		}
+
+		short OPLL_calc(OPLL opll)
+		{
+			if (!opll.quality)
+				return calc(opll);
+
+			while (opll.realstep > opll.oplltime)
+			{
+				opll.oplltime += opll.opllstep;
+				opll.prev = opll.next;
+				opll.next = calc(opll);
+			}
+
+			opll.oplltime -= opll.realstep;
+			opll.output = (short)(((double)opll.next * (opll.opllstep - opll.oplltime)
+									+ (double)opll.prev * opll.oplltime) / opll.opllstep);
+			return (short)opll.output;
+		}
+
+		uint OPLL_setMask(OPLL opll, uint mask)
+		{
+			uint ret;
+
+			if (opll != null)
+			{
+				ret = opll.mask;
+				opll.mask = mask;
+				return ret;
+			}
+			else
+				return 0;
+		}
+
+		uint OPLL_toggleMask(OPLL opll, uint mask)
+		{
+			uint ret;
+
+			if (opll != null)
+			{
+				ret = opll.mask;
+				opll.mask ^= mask;
+				return ret;
+			}
+			else
+				return 0;
+		}
+
+		/****************************************************
+
+							   I/O Ctrl
+
+		*****************************************************/
+
+		void OPLL_writeReg(OPLL opll, uint reg, uint data)
+		{
+			int i, v, ch;
+
+			data = data & 0xff;
+			reg = reg & 0x3f;
+			opll.reg[reg] = (byte)data;
+
+			switch (reg)
+			{
+				case 0x00:
+					opll.patch[0].am = (data >> 7) & 1;
+					opll.patch[0].pm = (data >> 6) & 1;
+					opll.patch[0].eg = (data >> 5) & 1;
+					opll.patch[0].kr = (data >> 4) & 1;
+					opll.patch[0].ml = (data) & 15;
+					for (i = 0; i < 9; i++)
+					{
+						if (opll.patch_number[i] == 0)
+						{
+							UPDATE_PG(MOD(opll, i));
+							UPDATE_RKS(MOD(opll, i));
+							UPDATE_EG(MOD(opll, i));
+						}
+					}
+					break;
+
+				case 0x01:
+					opll.patch[1].am = (data >> 7) & 1;
+					opll.patch[1].pm = (data >> 6) & 1;
+					opll.patch[1].eg = (data >> 5) & 1;
+					opll.patch[1].kr = (data >> 4) & 1;
+					opll.patch[1].ml = (data) & 15;
+					for (i = 0; i < 9; i++)
+					{
+						if (opll.patch_number[i] == 0)
+						{
+							UPDATE_PG(CAR(opll, i));
+							UPDATE_RKS(CAR(opll, i));
+							UPDATE_EG(CAR(opll, i));
+						}
+					}
+					break;
+
+				case 0x02:
+					opll.patch[0].kl = (data >> 6) & 3;
+					opll.patch[0].tl = (data) & 63;
+					for (i = 0; i < 9; i++)
+					{
+						if (opll.patch_number[i] == 0)
+						{
+							UPDATE_TLL(MOD(opll, i));
+						}
+					}
+					break;
+
+				case 0x03:
+					opll.patch[1].kl = (data >> 6) & 3;
+					opll.patch[1].wf = (data >> 4) & 1;
+					opll.patch[0].wf = (data >> 3) & 1;
+					opll.patch[0].fb = (data) & 7;
+					for (i = 0; i < 9; i++)
+					{
+						if (opll.patch_number[i] == 0)
+						{
+							UPDATE_WF(MOD(opll, i));
+							UPDATE_WF(CAR(opll, i));
+						}
+					}
+					break;
+
+				case 0x04:
+					opll.patch[0].ar = (data >> 4) & 15;
+					opll.patch[0].dr = (data) & 15;
+					for (i = 0; i < 9; i++)
+					{
+						if (opll.patch_number[i] == 0)
+						{
+							UPDATE_EG(MOD(opll, i));
+						}
+					}
+					break;
+
+				case 0x05:
+					opll.patch[1].ar = (data >> 4) & 15;
+					opll.patch[1].dr = (data) & 15;
+					for (i = 0; i < 9; i++)
+					{
+						if (opll.patch_number[i] == 0)
+						{
+							UPDATE_EG(CAR(opll, i));
+						}
+					}
+					break;
+
+				case 0x06:
+					opll.patch[0].sl = (data >> 4) & 15;
+					opll.patch[0].rr = (data) & 15;
+					for (i = 0; i < 9; i++)
+					{
+						if (opll.patch_number[i] == 0)
+						{
+							UPDATE_EG(MOD(opll, i));
+						}
+					}
+					break;
+
+				case 0x07:
+					opll.patch[1].sl = (data >> 4) & 15;
+					opll.patch[1].rr = (data) & 15;
+					for (i = 0; i < 9; i++)
+					{
+						if (opll.patch_number[i] == 0)
+						{
+							UPDATE_EG(CAR(opll, i));
+						}
+					}
+					break;
+
+				case 0x0e:
+					update_rhythm_mode(opll);
+					if ((data & 32) != 0)
+					{
+						if ((data & 0x10) != 0)
+							keyOn_BD(opll);
+						else
+							keyOff_BD(opll);
+						if ((data & 0x8) != 0)
+							keyOn_SD(opll);
+						else
+							keyOff_SD(opll);
+						if ((data & 0x4) != 0)
+							keyOn_TOM(opll);
+						else
+							keyOff_TOM(opll);
+						if ((data & 0x2) != 0)
+							keyOn_CYM(opll);
+						else
+							keyOff_CYM(opll);
+						if ((data & 0x1) != 0)
+							keyOn_HH(opll);
+						else
+							keyOff_HH(opll);
+					}
+					update_key_status(opll);
+
+					UPDATE_ALL(MOD(opll, 6));
+					UPDATE_ALL(CAR(opll, 6));
+					UPDATE_ALL(MOD(opll, 7));
+					UPDATE_ALL(CAR(opll, 7));
+					UPDATE_ALL(MOD(opll, 8));
+					UPDATE_ALL(CAR(opll, 8));
+
+					break;
+
+				case 0x0f:
+					break;
+
+				case 0x10:
+				case 0x11:
+				case 0x12:
+				case 0x13:
+				case 0x14:
+				case 0x15:
+				case 0x16:
+				case 0x17:
+				case 0x18:
+					ch = (int)(reg - 0x10);
+					setFnumber(opll, ch, (int)data + ((opll.reg[0x20 + ch] & 1) << 8));
+					UPDATE_ALL(MOD(opll, ch));
+					UPDATE_ALL(CAR(opll, ch));
+					break;
+
+				case 0x20:
+				case 0x21:
+				case 0x22:
+				case 0x23:
+				case 0x24:
+				case 0x25:
+				case 0x26:
+				case 0x27:
+				case 0x28:
+					ch = (int)(reg - 0x20);
+					setFnumber(opll, ch, (int)((data & 1) << 8) + opll.reg[0x10 + ch]);
+					setBlock(opll, ch, (int)(data >> 1) & 7);
+					setSustine(opll, ch, (int)(data >> 5) & 1);
+					if ((data & 0x10) != 0)
+						keyOn(opll, ch);
+					else
+						keyOff(opll, ch);
+					UPDATE_ALL(MOD(opll, ch));
+					UPDATE_ALL(CAR(opll, ch));
+					update_key_status(opll);
+					update_rhythm_mode(opll);
+					break;
+
+				case 0x30:
+				case 0x31:
+				case 0x32:
+				case 0x33:
+				case 0x34:
+				case 0x35:
+				case 0x36:
+				case 0x37:
+				case 0x38:
+					i = (int)((data >> 4) & 15);
+					v = (int)(data & 15);
+					if ((opll.reg[0x0e] & 32) != 0 && (reg >= 0x36))
+					{
+						switch (reg)
+						{
+							case 0x37:
+								setSlotVolume(MOD(opll, 7), i << 2);
+								break;
+							case 0x38:
+								setSlotVolume(MOD(opll, 8), i << 2);
+								break;
+							default:
+								break;
+						}
+					}
+					else
+					{
+						setPatch(opll, (int)(reg - 0x30), i);
+					}
+					setVolume(opll, (int)(reg - 0x30), v << 2);
+					UPDATE_ALL(MOD(opll, (int)(reg - 0x30)));
+					UPDATE_ALL(CAR(opll, (int)(reg - 0x30)));
+					break;
+
+				default:
+					break;
+
+			}
+		}
+
+		void OPLL_writeIO(OPLL opll, uint adr, uint val)
+		{
+			if ((adr & 1) != 0)
+				OPLL_writeReg(opll, opll.adr, val);
+			else
+				opll.adr = val;
+		}
+
+		/* STEREO MODE (OPT) */
+		void OPLL_set_pan(OPLL opll, uint ch, uint pan)
+		{
+			opll.pan[ch & 15] = pan & 3;
+		}
+
+		static void calc_stereo(OPLL opll, int[] output)
+		{
+			int[] b = new[] { 0, 0, 0, 0 };        /* Ignore, Right, Left, Center */
+			int[] r = new[] { 0, 0, 0, 0 };        /* Ignore, Right, Left, Center */
+			int i;
+
+			update_ampm(opll);
+			update_noise(opll);
+
+			for (i = 0; i < 18; i++)
+			{
+				calc_phase(opll.slot[i], opll.lfo_pm);
+				calc_envelope(opll.slot[i], opll.lfo_am);
+			}
+
+			for (i = 0; i < 6; i++)
+				if ((opll.mask & OPLL_MASK_CH(i)) == 0 && (CAR(opll, i).eg_mode != OPLL_EG_STATE.FINISH))
+					b[opll.pan[i]] += calc_slot_car(CAR(opll, i), calc_slot_mod(MOD(opll, i)));
+
+
+			if (opll.patch_number[6] <= 15)
+			{
+				if ((opll.mask & OPLL_MASK_CH(6)) == 0 && (CAR(opll, 6).eg_mode != OPLL_EG_STATE.FINISH))
+					b[opll.pan[6]] += calc_slot_car(CAR(opll, 6), calc_slot_mod(MOD(opll, 6)));
+			}
+			else
+			{
+				if ((opll.mask & OPLL_MASK_BD) == 0 && (CAR(opll, 6).eg_mode != OPLL_EG_STATE.FINISH))
+					r[opll.pan[9]] += calc_slot_car(CAR(opll, 6), calc_slot_mod(MOD(opll, 6)));
+			}
+
+			if (opll.patch_number[7] <= 15)
+			{
+				if ((opll.mask & OPLL_MASK_CH(7)) == 0 && (CAR(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
+					b[opll.pan[7]] += calc_slot_car(CAR(opll, 7), calc_slot_mod(MOD(opll, 7)));
+			}
+			else
+			{
+				if ((opll.mask & OPLL_MASK_HH) == 0 && (MOD(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
+					r[opll.pan[10]] += calc_slot_hat(MOD(opll, 7), (int)CAR(opll, 8).pgout, opll.noise_seed & 1);
+				if ((opll.mask & OPLL_MASK_SD) == 0 && (CAR(opll, 7).eg_mode != OPLL_EG_STATE.FINISH))
+					r[opll.pan[11]] -= calc_slot_snare(CAR(opll, 7), opll.noise_seed & 1);
+			}
+
+			if (opll.patch_number[8] <= 15)
+			{
+				if ((opll.mask & OPLL_MASK_CH(8)) == 0 && (CAR(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
+					b[opll.pan[8]] += calc_slot_car(CAR(opll, 8), calc_slot_mod(MOD(opll, 8)));
+			}
+			else
+			{
+				if ((opll.mask & OPLL_MASK_TOM) == 0 && (MOD(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
+					r[opll.pan[12]] += calc_slot_tom(MOD(opll, 8));
+				if ((opll.mask & OPLL_MASK_CYM) == 0 && (CAR(opll, 8).eg_mode != OPLL_EG_STATE.FINISH))
+					r[opll.pan[13]] -= calc_slot_cym(CAR(opll, 8), MOD(opll, 7).pgout);
+			}
+
+			output[1] = (b[1] + b[3] + ((r[1] + r[3]) << 1)) << 3;
+			output[0] = (b[2] + b[3] + ((r[2] + r[3]) << 1)) << 3;
+		}
+
+		void OPLL_calc_stereo(OPLL opll, int[] output)
+		{
+			if (!opll.quality)
+			{
+				calc_stereo(opll, output);
+				return;
+			}
+
+			while (opll.realstep > opll.oplltime)
+			{
+				opll.oplltime += opll.opllstep;
+				opll.sprev[0] = opll.snext[0];
+				opll.sprev[1] = opll.snext[1];
+				calc_stereo(opll, opll.snext);
+			}
+
+			opll.oplltime -= opll.realstep;
+			output[0] = (short)(((double)opll.snext[0] * (opll.opllstep - opll.oplltime)
+								 + (double)opll.sprev[0] * opll.oplltime) / opll.opllstep);
+			output[1] = (short)(((double)opll.snext[1] * (opll.opllstep - opll.oplltime)
+								 + (double)opll.sprev[1] * opll.oplltime) / opll.opllstep);
+		}
+
+		/* voice data */
+		public sealed class OPLL_PATCH : ICloneable
+		{
+			public uint tl, fb, eg, ml, ar, dr, sl, rr, kr, kl, am, pm, wf;
+
+			public object Clone()
+			{
+				OPLL_PATCH o = new OPLL_PATCH();
+				o.tl = this.tl; o.fb = this.fb; o.eg = this.eg; o.ml = this.ml; o.ar = this.ar; o.dr = this.dr; o.sl = this.sl; o.rr = this.rr; o.kr = this.kr; o.kl = this.kl; o.am = this.am; o.pm = this.pm; o.wf = this.wf;
+				return o;
+			}
+		}
+
+		/* slot */
+		public sealed class OPLL_SLOT
+		{
+			public OPLL_PATCH patch;
+
+			public int type;          /* 0 : modulator 1 : carrier */
+
+			/* OUTPUT */
+			public int feedback;
+
+			public int[] output = new int[2];   /* Output value of slot */
+
+			/* for Phase Generator (PG) */
+			public short[] sintbl;   /* Wavetable */
+			public uint phase;      /* Phase */
+			public uint dphase;     /* Phase increment amount */
+			public uint pgout;      /* output */
+
+			/* for Envelope Generator (EG) */
+			public int fnum;          /* F-Number */
+			public int block;         /* Block */
+			public int volume;        /* Current volume */
+			public int sustine;       /* Sustine 1 = ON, 0 = OFF */
+			public uint tll;	      /* Total Level + Key scale level*/
+			public uint rks;        /* Key scale offset (Rks) */
+			public OPLL_EG_STATE eg_mode;       /* Current state */
+			public uint eg_phase;   /* Phase */
+			public uint eg_dphase;  /* Phase increment amount */
+			public uint egout;      /* output */
+
+		}
+
+		public sealed class OPLL
+		{
+			public uint adr;
+			public int output;
+
+			public uint realstep;
+			public uint oplltime;
+			public uint opllstep;
+			public int prev, next;
+			public int[] sprev = new int[2], snext = new int[2];
+			public uint[] pan = new uint[16];
+
+			/* Register */
+			public byte[] reg = new byte[0x40];
+			public int[] slot_on_flag = new int[18];
+
+			/* Pitch Modulator */
+			public uint pm_phase;
+			public int lfo_pm;
+
+			/* Amp Modulator */
+			public int am_phase;
+			public int lfo_am;
+
+			public bool quality;
+
+			/* Noise Generator */
+			public uint noise_seed;
+
+			/* Channel Data */
+			public int[] patch_number = new int[9];
+			public int[] key_status = new int[9];
+
+			/* Slot */
+			public OPLL_SLOT[] slot = new OPLL_SLOT[18];
+
+			/* Voice Data */
+			public OPLL_PATCH[] patch = new OPLL_PATCH[19 * 2];
+			public int[] patch_update = new int[2]; /* flag for check patch update */
+
+			public uint mask;
+
+			public OPLL()
+			{
+				for (int i = 0; i < this.slot.Length; ++i) this.slot[i] = new OPLL_SLOT();
+				for (int i = 0; i < this.patch.Length; i++) this.patch[i] = new OPLL_PATCH();
+			}
+
+		}
+
+		#endregion
+	}
 }
diff --git a/BizHawk.Emulation/Util.cs b/BizHawk.Emulation/Util.cs
deleted file mode 100644
index 00cea5e7e2..0000000000
--- a/BizHawk.Emulation/Util.cs
+++ /dev/null
@@ -1,922 +0,0 @@
-using System;
-using System.Linq;
-using System.Reflection;
-using System.Diagnostics;
-using System.Collections;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Text;
-
-using BizHawk.Common;
-
-namespace BizHawk
-{
-
-	public static class Colors
-	{
-		public static int ARGB(byte red, byte green, byte blue)
-		{
-			return (int)((uint)((red << 0x10) | (green << 8) | blue | (0xFF << 0x18)));
-		}
-
-		public static int ARGB(byte red, byte green, byte blue, byte alpha)
-		{
-			return (int)((uint)((red << 0x10) | (green << 8) | blue | (alpha << 0x18)));
-		}
-
-		public static int Luminosity(byte lum)
-		{
-			return (int)((uint)((lum << 0x10) | (lum << 8) | lum | (0xFF << 0x18)));
-		}
-	}
-
-	public unsafe static class Util
-	{
-		static readonly char[] HexConvArr = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-		static System.Runtime.InteropServices.GCHandle HexConvHandle;
-		public static char* HexConvPtr;
-		static unsafe Util()
-		{
-			HexConvHandle = System.Runtime.InteropServices.GCHandle.Alloc(HexConvArr, System.Runtime.InteropServices.GCHandleType.Pinned);
-			HexConvPtr = (char*)HexConvHandle.AddrOfPinnedObject().ToPointer();
-		}
-
-		public static string Hash_MD5(byte[] data, int offset, int len)
-		{
-			using (var md5 = System.Security.Cryptography.MD5.Create())
-			{
-				md5.TransformFinalBlock(data, offset, len);
-				return Util.BytesToHexString(md5.Hash);
-			}
-		}
-
-		public static string Hash_SHA1(byte[] data, int offset, int len)
-		{
-			using (var sha1 = System.Security.Cryptography.SHA1.Create())
-			{
-				sha1.TransformFinalBlock(data, offset, len);
-				return Util.BytesToHexString(sha1.Hash);
-			}
-		}
-
-		public static bool IsPowerOfTwo(int x)
-		{
-			if (x == 0) return true;
-			if (x == 1) return true;
-			return (x & (x - 1)) == 0;
-		}
-
-		public static int SaveRamBytesUsed(byte[] SaveRAM)
-		{
-			for (int j = SaveRAM.Length - 1; j >= 0; j--)
-				if (SaveRAM[j] != 0)
-					return j + 1;
-			return 0;
-		}
-
-		// Read bytes from a BinaryReader and translate them into the UTF-8 string they represent.
-		public static string ReadStringFixedAscii(this BinaryReader r, int bytes)
-		{
-			byte[] read = new byte[bytes];
-			for (int b = 0; b < bytes; b++)
-				read[b] = r.ReadByte();
-			return System.Text.Encoding.UTF8.GetString(read);
-		}
-
-		public static string ReadStringAsciiZ(this BinaryReader r)
-		{
-			StringBuilder sb = new StringBuilder();
-			for(;;)
-			{
-				int b = r.ReadByte();
-				if(b <= 0) break;
-				sb.Append((char)b);
-			}
-			return sb.ToString();
-		}
-
-		/// <summary>
-		/// conerts bytes to an uppercase string of hex numbers in upper case without any spacing or anything
-		/// //could be extension method
-		/// </summary>
-		public static string BytesToHexString(byte[] bytes)
-		{
-			StringBuilder sb = new StringBuilder();
-			foreach (byte b in bytes)
-				sb.AppendFormat("{0:X2}", b);
-			return sb.ToString();
-		}
-
-		//could be extension method
-		public static byte[] HexStringToBytes(string str)
-		{
-			MemoryStream ms = new MemoryStream();
-			if (str.Length % 2 != 0) throw new ArgumentException();
-			int len = str.Length / 2;
-			for (int i = 0; i < len; i++)
-			{
-				int d = 0;
-				for (int j = 0; j < 2; j++)
-				{
-					char c = char.ToLower(str[i * 2 + j]);
-					if (c >= '0' && c <= '9')
-						d += (c - '0');
-					else if (c >= 'a' && c <= 'f')
-						d += (c - 'a') + 10;
-					else throw new ArgumentException();
-					if (j == 0) d <<= 4;
-				}
-				ms.WriteByte((byte)d);
-			}
-			return ms.ToArray();
-		}
-
-		//could be extension method
-		public static void WriteByteBuffer(BinaryWriter bw, byte[] data)
-		{
-			if (data == null) bw.Write(0);
-			else
-			{
-				bw.Write(data.Length);
-				bw.Write(data);
-			}
-		}
-
-		public static short[] ByteBufferToShortBuffer(byte[] buf)
-		{
-			int num = buf.Length / 2;
-			short[] ret = new short[num];
-			for (int i = 0; i < num; i++)
-			{
-				ret[i] = (short)(buf[i * 2] | (buf[i * 2 + 1] << 8));
-			}
-			return ret;
-		}
-
-		public static byte[] ShortBufferToByteBuffer(short[] buf)
-		{
-			int num = buf.Length;
-			byte[] ret = new byte[num * 2];
-			for (int i = 0; i < num; i++)
-			{
-				ret[i * 2 + 0] = (byte)(buf[i] & 0xFF);
-				ret[i * 2 + 1] = (byte)((buf[i] >> 8) & 0xFF);
-			}
-			return ret;
-		}
-
-		public static uint[] ByteBufferToUintBuffer(byte[] buf)
-		{
-			int num = buf.Length / 4;
-			uint[] ret = new uint[num];
-			for (int i = 0; i < num; i++)
-			{
-				ret[i] = (uint)(buf[i * 4] | (buf[i * 4 + 1] << 8) | (buf[i * 4 + 2] << 16) | (buf[i * 4 + 3] << 24));
-			}
-			return ret;
-		}
-
-		public static byte[] UintBufferToByteBuffer(uint[] buf)
-		{
-			int num = buf.Length;
-			byte[] ret = new byte[num * 4];
-			for (int i = 0; i < num; i++)
-			{
-				ret[i * 4 + 0] = (byte)(buf[i] & 0xFF);
-				ret[i * 4 + 1] = (byte)((buf[i] >> 8) & 0xFF);
-				ret[i * 4 + 2] = (byte)((buf[i] >> 16) & 0xFF);
-				ret[i * 4 + 3] = (byte)((buf[i] >> 24) & 0xFF);
-			}
-			return ret;
-		}
-
-		public static int[] ByteBufferToIntBuffer(byte[] buf)
-		{
-			int num = buf.Length / 4;
-			int[] ret = new int[num];
-			for (int i = 0; i < num; i++)
-			{
-				ret[i] = buf[(i * 4) + 3];
-				ret[i] <<= 8;
-				ret[i] |= buf[(i * 4) + 2];
-				ret[i] <<= 8;
-				ret[i] |= buf[(i * 4) + 1];
-				ret[i] <<= 8;
-				ret[i] |= buf[(i * 4)];
-			}
-			return ret;
-		}
-
-		public static byte[] IntBufferToByteBuffer(int[] buf)
-		{
-			int num = buf.Length;
-			byte[] ret = new byte[num * 4];
-			for (int i = 0; i < num; i++)
-			{
-				ret[i * 4 + 0] = (byte)(buf[i] & 0xFF);
-				ret[i * 4 + 1] = (byte)((buf[i] >> 8) & 0xFF);
-				ret[i * 4 + 2] = (byte)((buf[i] >> 16) & 0xFF);
-				ret[i * 4 + 3] = (byte)((buf[i] >> 24) & 0xFF);
-			}
-			return ret;
-		}
-
-		public static byte[] ReadByteBuffer(BinaryReader br, bool return_null)
-		{
-			int len = br.ReadInt32();
-			if (len == 0 && return_null) return null;
-			byte[] ret = new byte[len];
-			int ofs = 0;
-			while (len > 0)
-			{
-				int done = br.Read(ret, ofs, len);
-				ofs += done;
-				len -= done;
-			}
-			return ret;
-		}
-
-		public static unsafe int memcmp(void* a, string b, int len)
-		{
-			fixed (byte* bp = System.Text.Encoding.ASCII.GetBytes(b))
-				return memcmp(a, bp, len);
-		}
-
-		public static unsafe int memcmp(void* a, void* b, int len)
-		{
-			byte* ba = (byte*)a;
-			byte* bb = (byte*)b;
-			for (int i = 0; i < len; i++)
-			{
-				byte _a = ba[i];
-				byte _b = bb[i];
-				int c = _a - _b;
-				if (c != 0) return c;
-			}
-			return 0;
-		}
-
-		public static unsafe void memset(void* ptr, int val, int len)
-		{
-			byte* bptr = (byte*)ptr;
-			for (int i = 0; i < len; i++)
-				bptr[i] = (byte)val;
-		}
-
-		public static unsafe void memset32(void* ptr, int val, int len)
-		{
-			System.Diagnostics.Debug.Assert(len % 4 == 0);
-			int dwords = len / 4;
-			int* dwptr = (int*)ptr;
-			for (int i = 0; i < dwords; i++)
-				dwptr[i] = val;
-		}
-
-		public static byte[] ReadAllBytes(Stream stream)
-		{
-			const int BUFF_SIZE = 4096;
-			byte[] buffer = new byte[BUFF_SIZE];
-
-			int bytesRead = 0;
-			var inStream = new BufferedStream(stream);
-			var outStream = new MemoryStream();
-
-			while ((bytesRead = inStream.Read(buffer, 0, BUFF_SIZE)) > 0)
-			{
-				outStream.Write(buffer, 0, bytesRead);
-			}
-
-			return outStream.ToArray();
-		}
-
-        public static byte BinToBCD(this byte v)
-        {
-            return (byte) (((v / 10) * 16) + (v % 10));
-        }
-
-        public static byte BCDtoBin(this byte v)
-        {
-            return (byte) (((v / 16) * 10) + (v % 16));
-        }
-
-		public static string FormatFileSize(long filesize)
-		{
-			Decimal size = (Decimal)filesize;
-
-			Decimal OneKiloByte = 1024M;
-			Decimal OneMegaByte = OneKiloByte * 1024M;
-			Decimal OneGigaByte = OneMegaByte * 1024M;
-
-			string suffix;
-			if (size > 1024 * 1024 * 1024)
-			{
-				size /= 1024 * 1024 * 1024;
-				suffix = "GB";
-			}
-			else if (size > 1024 * 1024)
-			{
-				size /= 1024 * 1024;
-				suffix = "MB";
-			}
-			else if (size > 1024)
-			{
-				size /= 1024;
-				suffix = "KB";
-			}
-			else
-			{
-				suffix = " B";
-			}
-
-			string precision = "2";
-			return String.Format("{0:N" + precision + "}{1}", size, suffix);
-		}
-	}
-
-	public unsafe class Serializer
-	{
-		BinaryReader br;
-		BinaryWriter bw;
-		TextReader tr;
-		TextWriter tw;
-		public BinaryReader BinaryReader { get { return br; } }
-		public BinaryWriter BinaryWriter { get { return bw; } }
-		public TextReader TextReader { get { return tr; } }
-		public TextWriter TextWriter { get { return tw; } }
-		public Serializer() { }
-		public Serializer(BinaryWriter _bw) { StartWrite(_bw); }
-		public Serializer(BinaryReader _br) { StartRead(_br); }
-		public Serializer(TextWriter _tw) { StartWrite(_tw); }
-		public Serializer(TextReader _tr) { StartRead(_tr); }
-		public static Serializer CreateBinaryWriter(BinaryWriter _bw) { return new Serializer(_bw); }
-		public static Serializer CreateBinaryReader(BinaryReader _br) { return new Serializer(_br); }
-		public static Serializer CreateTextWriter(TextWriter _tw) { return new Serializer(_tw); }
-		public static Serializer CreateTextReader(TextReader _tr) { return new Serializer(_tr); }
-		public void StartWrite(BinaryWriter _bw) { this.bw = _bw; isReader = false; }
-		public void StartRead(BinaryReader _br) { this.br = _br; isReader = true; }
-		public void StartWrite(TextWriter _tw) { this.tw = _tw; isReader = false; isText = true; }
-		public void StartRead(TextReader _tr) {
-			this.tr = _tr;
-			isReader = true; 
-			isText = true;
-			BeginTextBlock();
-		}
-
-		public bool IsReader { get { return isReader; } }
-		public bool IsWriter { get { return !IsReader; } }
-		public bool IsText { get { return isText; } }
-		bool isText;
-		bool isReader;
-
-		Stack<string> sections = new Stack<string>();
-
-		class Section : Dictionary<string, Section>
-		{
-			public string Name;
-			public Dictionary<string, string> Items = new Dictionary<string, string>();
-		}
-
-		Section ReaderSection, CurrSection;
-		Stack<Section> SectionStack = new Stack<Section>();
-
-		void BeginTextBlock()
-		{
-			if (!IsText) return;
-			if (IsWriter) return;
-
-			ReaderSection = new Section();
-			ReaderSection.Name = "";
-			Stack<Section> ss = new Stack<Section>();
-			ss.Push(ReaderSection);
-			Section curs = ReaderSection;
-
-			var rxEnd = new System.Text.RegularExpressions.Regex(@"\[/(.*?)\]",System.Text.RegularExpressions.RegexOptions.Compiled);
-			var rxBegin = new System.Text.RegularExpressions.Regex(@"\[(.*?)\]",System.Text.RegularExpressions.RegexOptions.Compiled);
-
-			//read the entire file into a data structure for flexi-parsing
-			string str;
-			while ((str = tr.ReadLine()) != null)
-			{
-				var end = rxEnd.Match(str);
-				var begin = rxBegin.Match(str);
-				if (end.Success)
-				{
-					string name = end.Groups[1].Value;
-					if (name != curs.Name) throw new InvalidOperationException("Mis-formed savestate blob");
-					curs = ss.Pop();
-					// consume no data past the end of the last proper section
-					if (curs == ReaderSection)
-					{
-						CurrSection = curs;
-						return;
-					}
-				}
-				else if (begin.Success)
-				{
-					string name = begin.Groups[1].Value;
-					ss.Push(curs);
-					var news = new Section();
-					news.Name = name;
-					if (!curs.ContainsKey(name))
-						curs[name] = news;
-					else
-						throw new Exception(string.Format("Duplicate key \"{0}\" in serializer savestate!", name));
-					curs = news;
-				}
-				else
-				{
-					//add to current section
-					if (str.Trim().Length == 0) continue;
-					var parts = str.Split(' ');
-					var key = parts[0];
-					//UGLY: adds whole string instead of splitting the key. later, split the key, and have the individual Sync methods give up that responsibility
-					if (!curs.Items.ContainsKey(key))
-						curs.Items[key] = parts[1];
-					else
-						throw new Exception(string.Format("Duplicate key \"{0}\" in serializer savestate!", key));
-				}
-			}
-
-			CurrSection = ReaderSection;
-		}
-
-		public void BeginSection(string name)
-		{
-			sections.Push(name);
-			if (IsText) 
-				if (IsWriter) { tw.WriteLine("[{0}]", name); }
-				else 
-				{
-					SectionStack.Push(CurrSection);
-					CurrSection = CurrSection[name];
-				}
-		}
-
-		public void EndSection()
-		{
-			string name = sections.Pop();
-			if (IsText)
-				if (IsWriter) tw.WriteLine("[/{0}]", name);
-				else
-				{
-					CurrSection = SectionStack.Pop();
-				}
-		}
-
-		string Item(string key)
-		{
-			return CurrSection.Items[key];
-		}
-
-		bool Present(string key)
-		{
-			return CurrSection.Items.ContainsKey(key);
-		}
-
-		public void SyncEnum<T>(string name, ref T val) where T : struct
-		{
-			if (typeof(T).BaseType != typeof(System.Enum))
-				throw new InvalidOperationException();
-			if (isText) SyncEnumText<T>(name, ref val);
-			else if (IsReader) val = (T)Enum.ToObject(typeof(T), br.ReadInt32());
-			else bw.Write(Convert.ToInt32(val));
-		}
-
-		public void SyncEnumText<T>(string name, ref T val) where T : struct
-		{
-			if (IsReader) { if (Present(name)) val = (T)Enum.Parse(typeof(T), Item(name)); }
-			else tw.WriteLine("{0} {1}", name, val.ToString());
-		}
-
-		void SyncBuffer(string name, int elemsize, int len, void* ptr)
-		{
-			if (IsReader)
-			{
-				byte[] temp = null;
-				Sync(name, ref temp, false);
-				int todo = Math.Min(temp.Length, len * elemsize);
-				System.Runtime.InteropServices.Marshal.Copy(temp, 0, new IntPtr(ptr), todo);
-			}
-			else
-			{
-				int todo = len * elemsize;
-				byte[] temp = new byte[todo];
-				System.Runtime.InteropServices.Marshal.Copy(new IntPtr(ptr), temp, 0, todo);
-				Sync(name, ref temp, false);
-			}
-		}
-
-		public void Sync(string name, ref ByteBuffer byteBuf)
-		{
-			SyncBuffer(name, 1, byteBuf.len, byteBuf.ptr);
-		}
-
-		public void Sync(string name, ref IntBuffer byteBuf)
-		{
-			SyncBuffer(name, 4, byteBuf.len, byteBuf.ptr);
-		}
-
-		public void Sync(string name, ref byte[] val, bool use_null)
-		{
-			if (IsText) SyncText(name, ref val, use_null);
-			else if (IsReader) val = Util.ReadByteBuffer(br, use_null);
-			else Util.WriteByteBuffer(bw, val);
-		}
-		public void SyncText(string name, ref byte[] val, bool use_null)
-		{
-			if (IsReader)
-			{
-				if(Present(name)) val = Util.HexStringToBytes(Item(name));
-				if (val != null && val.Length == 0 && use_null) val = null;
-			}
-			else
-			{
-				byte[] temp = val;
-				if (temp == null) temp = new byte[0];
-				tw.WriteLine("{0} {1}", name, Util.BytesToHexString(temp));
-			}
-		}
-
-		public void Sync(string name, ref short[] val, bool use_null)
-		{
-			if (IsText) SyncText(name, ref val, use_null);
-			else if (IsReader)
-			{
-				val = Util.ByteBufferToShortBuffer(Util.ReadByteBuffer(br, false));
-				if (val == null && !use_null) val = new short[0];
-			}
-			else Util.WriteByteBuffer(bw, Util.ShortBufferToByteBuffer(val));
-		}
-		public void SyncText(string name, ref short[] val, bool use_null)
-		{
-			if (IsReader)
-			{
-				if (Present(name))
-				{
-					byte[] bytes = Util.HexStringToBytes(Item(name));
-					val = Util.ByteBufferToShortBuffer(bytes);
-				}
-				if (val != null && val.Length == 0 && use_null) val = null;
-			}
-			else
-			{
-				short[] temp = val;
-				if (temp == null) temp = new short[0];
-				tw.WriteLine("{0} {1}", name, Util.BytesToHexString(Util.ShortBufferToByteBuffer(temp)));
-			}
-		}
-
-		public void Sync(string name, ref int[] val, bool use_null)
-		{
-			if (IsText) SyncText(name, ref val, use_null);
-			else if (IsReader)
-			{
-				val = Util.ByteBufferToIntBuffer(Util.ReadByteBuffer(br, false));
-				if (val == null && !use_null) val = new int[0];
-			}
-			else Util.WriteByteBuffer(bw, Util.IntBufferToByteBuffer(val));
-		}
-		public void SyncText(string name, ref int[] val, bool use_null)
-		{
-			if (IsReader)
-			{
-				if (Present(name))
-				{
-					byte[] bytes = Util.HexStringToBytes(Item(name));
-					val = Util.ByteBufferToIntBuffer(bytes);
-				}
-				if (val != null && val.Length == 0 && use_null) val = null;
-			}
-			else
-			{
-				int[] temp = val;
-				if (temp == null) temp = new int[0];
-				tw.WriteLine("{0} {1}", name, Util.BytesToHexString(Util.IntBufferToByteBuffer(temp)));
-			}
-		}
-
-		public void Sync(string name, ref uint[] val, bool use_null)
-		{
-			if (IsText) SyncText(name, ref val, use_null);
-			else if (IsReader)
-			{
-				val = Util.ByteBufferToUintBuffer(Util.ReadByteBuffer(br, false));
-				if (val == null && !use_null) val = new uint[0];
-			}
-			else Util.WriteByteBuffer(bw, Util.UintBufferToByteBuffer(val));
-		}
-		public void SyncText(string name, ref uint[] val, bool use_null)
-		{
-			if (IsReader)
-			{
-				if(Present(name))
-				{
-					byte[] bytes = Util.HexStringToBytes(Item(name));
-					val = Util.ByteBufferToUintBuffer(bytes);
-				}
-				if (val != null && val.Length == 0 && use_null) val = null;
-			}
-			else
-			{
-				uint[] temp = val;
-				if (temp == null) temp = new uint[0];
-				tw.WriteLine("{0} {1}", name, Util.BytesToHexString(Util.UintBufferToByteBuffer(temp)));
-			}
-		}
-
-		public void Sync(string name, ref Bit val)
-		{
-			if (IsText) SyncText(name, ref val);
-			else if (IsReader) Read(ref val);
-			else Write(ref val);
-		}
-		public void SyncText(string name, ref Bit val)
-		{
-			if (IsReader) ReadText(name, ref val);
-			else WriteText(name, ref val);
-		}
-		public void Sync(string name, ref byte val)
-		{
-			if (IsText) SyncText(name, ref val);
-			else if (IsReader) Read(ref val);
-			else Write(ref val);
-		}
-		void SyncText(string name, ref byte val)
-		{
-			if (IsReader) ReadText(name, ref val);
-			else WriteText(name, ref val);
-		}
-		public void Sync(string name, ref ushort val)
-		{
-			if (IsText) SyncText(name, ref val);
-			else if (IsReader) Read(ref val);
-			else Write(ref val);
-		}
-		void SyncText(string name, ref ushort val)
-		{
-			if (IsReader) ReadText(name, ref val);
-			else WriteText(name, ref val);
-		}
-		public void Sync(string name, ref uint val)
-		{
-			if (IsText) SyncText(name, ref val);
-			else if (IsReader) Read(ref val);
-			else Write(ref val);
-		}
-		void SyncText(string name, ref uint val)
-		{
-			if (IsReader) ReadText(name, ref val);
-			else WriteText(name, ref val);
-		}
-		public void Sync(string name, ref sbyte val)
-		{
-			if (IsText) SyncText(name, ref val);
-			else if (IsReader) Read(ref val);
-			else Write(ref val);
-		}
-		void SyncText(string name, ref sbyte val)
-		{
-			if (IsReader) ReadText(name, ref val);
-			else WriteText(name, ref val);
-		}
-		public void Sync(string name, ref short val)
-		{
-			if (IsText) SyncText(name, ref val);
-			else if (IsReader) Read(ref val);
-			else Write(ref val);
-		}
-		void SyncText(string name, ref short val)
-		{
-			if (IsReader) ReadText(name, ref val);
-			else WriteText(name, ref val);
-		}
-		public void Sync(string name, ref int val)
-		{
-			if (IsText) SyncText(name, ref val);
-			else if (IsReader) Read(ref val);
-			else Write(ref val);
-		}
-		void SyncText(string name, ref int val)
-		{
-			if (IsReader) ReadText(name, ref val);
-			else WriteText(name, ref val);
-		}
-		public void Sync(string name, ref bool val)
-		{
-			if (IsText) SyncText(name, ref val);
-			else if (IsReader) Read(ref val);
-			else Write(ref val);
-		}
-		void SyncText(string name, ref bool val)
-		{
-			if (IsReader) ReadText(name, ref val);
-			else WriteText(name, ref val);
-		}
-		public void SyncFixedString(string name, ref string val, int length)
-		{
-			//TODO - this could be made more efficient perhaps just by writing values right out of the string..
-
-			if (IsReader)
-			{
-				char[] buf = new char[length];
-				if (isText)
-				{
-					tr.Read(buf, 0, length);
-				}
-				else
-				{
-					br.Read(buf, 0, length);
-				}
-				int len = 0;
-				for (; len < length; len++)
-				{
-					if (buf[len] == 0) break;
-				}
-				val = new string(buf, 0, len);
-			}
-			else
-			{
-				if (name.Length > length) throw new InvalidOperationException("SyncFixedString too long");
-				char[] buf = val.ToCharArray();
-				char[] remainder = new char[length - buf.Length];
-				if (IsText)
-				{
-					tw.Write(buf);
-					tw.Write(remainder);
-				}
-				else
-				{
-					bw.Write(buf);
-					bw.Write(remainder);
-				}
-			}
-		}
-
-		void Read(ref Bit val) { val = br.ReadBit(); }
-		void Write(ref Bit val) { bw.WriteBit(val); }
-		void ReadText(string name, ref Bit val) { if(Present(name)) val = (Bit)int.Parse(Item(name)); }
-		void WriteText(string name, ref Bit val) { tw.WriteLine("{0} {1}", name, (int)val); }
-
-		void Read(ref byte val) { val = br.ReadByte(); }
-		void Write(ref byte val) { bw.Write(val); }
-		void ReadText(string name, ref byte val) { if (Present(name)) val = byte.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
-		void WriteText(string name, ref byte val) { tw.WriteLine("{0} 0x{1:X2}", name, val); }
-
-		void Read(ref ushort val) { val = br.ReadUInt16(); }
-		void Write(ref ushort val) { bw.Write(val); }
-		void ReadText(string name, ref ushort val) { if (Present(name)) val = ushort.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
-		void WriteText(string name, ref ushort val) { tw.WriteLine("{0} 0x{1:X4}", name, val); }
-
-		void Read(ref uint val) { val = br.ReadUInt32(); }
-		void Write(ref uint val) { bw.Write(val); }
-		void ReadText(string name, ref uint val) { if (Present(name)) val = uint.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
-		void WriteText(string name, ref uint val) { tw.WriteLine("{0} 0x{1:X8}", name, val); }
-
-		void Read(ref sbyte val) { val = br.ReadSByte(); }
-		void Write(ref sbyte val) { bw.Write(val); }
-		void ReadText(string name, ref sbyte val) { if (Present(name)) val = sbyte.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
-		void WriteText(string name, ref sbyte val) { tw.WriteLine("{0} 0x{1:X2}", name, val); }
-
-		void Read(ref short val) { val = br.ReadInt16(); }
-		void Write(ref short val) { bw.Write(val); }
-		void ReadText(string name, ref short val) { if (Present(name)) val = short.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
-		void WriteText(string name, ref short val) { tw.WriteLine("{0} 0x{1:X4}", name, val); }
-
-		void Read(ref int val) { val = br.ReadInt32(); }
-		void Write(ref int val) { bw.Write(val); }
-		void ReadText(string name, ref int val) { if (Present(name)) val = int.Parse(Item(name).Replace("0x", ""), NumberStyles.HexNumber); }
-		void WriteText(string name, ref int val) { tw.WriteLine("{0} 0x{1:X8}", name, val); }
-
-		void Read(ref bool val) { val = br.ReadBoolean(); }
-		void Write(ref bool val) { bw.Write(val); }
-		void ReadText(string name, ref bool val) { if (Present(name)) val = bool.Parse(Item(name)); }
-		void WriteText(string name, ref bool val) { tw.WriteLine("{0} {1}", name, val); }
-	}
-
-
-	public static class BITREV
-	{
-		public static byte[] byte_8;
-		static BITREV()
-		{
-			make_byte_8();
-		}
-		static void make_byte_8()
-		{
-			int bits = 8;
-			int n = 1 << 8;
-			byte_8 = new byte[n];
-
-			int m = 1;
-			int a = n >> 1;
-			int j = 2;
-
-			byte_8[0] = 0;
-			byte_8[1] = (byte)a;
-
-			while ((--bits) != 0)
-			{
-				m <<= 1;
-				a >>= 1;
-				for (int i = 0; i < m; i++)
-					byte_8[j++] = (byte)(byte_8[i] + a);
-			}
-		}
-
-		public static uint reverse_32(uint v)
-		{
-			return (uint)((byte_8[v & 0xff] << 24) |
-					(byte_8[(v >> 8) & 0xff] << 16) |
-					(byte_8[(v >> 16) & 0xff] << 8) |
-					(byte_8[(v >> 24) & 0xff]));
-		}
-	}
-
-	/// <summary>
-	/// a Dictionary-of-lists with key K and values List&lt;V&gt;
-	/// </summary>
-	[Serializable]
-	public class Bag<K, V> : BagBase<K, V, Dictionary<K, List<V>>, List<V>> { }
-
-	/// <summary>
-	/// a Dictionary-of-lists with key K and values List&lt;V&gt;
-	/// </summary>
-	[Serializable]
-	public class SortedBag<K, V> : BagBase<K, V, SortedDictionary<K, List<V>>, List<V>> { }
-
-	/// <summary>
-	/// A dictionary that creates new values on the fly as necessary so that any key you need will be defined. 
-	/// </summary>
-	/// <typeparam name="K">dictionary keys</typeparam>
-	/// <typeparam name="V">dictionary values</typeparam>
-	public class WorkingDictionary<K, V> : Dictionary<K, V> where V : new()
-	{
-		public new V this[K key]
-		{
-			get
-			{
-				V temp;
-				if (!TryGetValue(key, out temp))
-					temp = this[key] = new V();
-				return temp;
-			}
-			set { base[key] = value; }
-		}
-	}
-
-	/// <summary>
-	/// base class for Bag and SortedBag
-	/// </summary>
-	/// <typeparam name="K">dictionary keys</typeparam>
-	/// <typeparam name="V">list values</typeparam>
-	/// <typeparam name="D">dictionary type</typeparam>
-	/// <typeparam name="L">list type</typeparam>
-	[Serializable]
-	public class BagBase<K, V, D, L> : IEnumerable<V>
-		where D : IDictionary<K, L>, new()
-		where L : IList<V>, IEnumerable<V>, new()
-	{
-		D dictionary = new D();
-		public void Add(K key, V val)
-		{
-			this[key].Add(val);
-		}
-
-		public bool ContainsKey(K key) { return dictionary.ContainsKey(key); }
-
-		IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }
-		public IEnumerator<V> GetEnumerator()
-		{
-			foreach (L lv in dictionary.Values)
-				foreach (V v in lv)
-					yield return v;
-		}
-
-		public IEnumerable KeyValuePairEnumerator { get { return dictionary; } }
-
-		/// <summary>
-		/// the list of keys contained herein
-		/// </summary>
-		public IList<K> Keys { get { return new List<K>(dictionary.Keys); } }
-
-		public L this[K key]
-		{
-			get
-			{
-				L slot;
-				if (!dictionary.TryGetValue(key, out slot))
-					dictionary[key] = slot = new L();
-				return slot;
-			}
-			set
-			{
-				dictionary[key] = value;
-			}
-		}
-	}
-
-    public class NotTestedException : Exception
-    {
-    }
-}