diff --git a/BizHawk.Emulation/BizHawk.Emulation.csproj b/BizHawk.Emulation/BizHawk.Emulation.csproj
index d6bcb17a73..6daac71852 100644
--- a/BizHawk.Emulation/BizHawk.Emulation.csproj
+++ b/BizHawk.Emulation/BizHawk.Emulation.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -49,6 +49,7 @@
   <ItemGroup>
     <Compile Include="Consoles\Sega\SMS\MemoryMap.CodeMasters.cs" />
     <Compile Include="Consoles\Sega\SMS\MemoryMap.Sega.cs" />
+    <Compile Include="Consoles\Sega\SMS\VDP.Mode4.cs" />
     <Compile Include="Consoles\Sega\SMS\VDP.Tables.cs" />
     <Compile Include="CPUs\68000\Diassembler.cs" />
     <Compile Include="CPUs\68000\Instructions\BitArithemetic.cs" />
@@ -150,7 +151,6 @@
     <Content Include="Consoles\Sega\SMS\Compat.txt" />
     <Content Include="Notes.txt" />
   </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/BizHawk.Emulation/Consoles/PC Engine/VDC.Render.cs b/BizHawk.Emulation/Consoles/PC Engine/VDC.Render.cs
index 8ddbaf9f6a..18b497b750 100644
--- a/BizHawk.Emulation/Consoles/PC Engine/VDC.Render.cs	
+++ b/BizHawk.Emulation/Consoles/PC Engine/VDC.Render.cs	
@@ -1,4 +1,6 @@
-namespace BizHawk.Emulation.Consoles.TurboGrafx
+using System;
+
+namespace BizHawk.Emulation.Consoles.TurboGrafx
 {
     // This rendering code is only used for TurboGrafx/TurboCD Mode.
     // In SuperGrafx mode, separate rendering functions in the VPC class are used.
@@ -104,9 +106,7 @@
 
         private void RenderBackgroundScanline()
         {
-            // clear priority buffer
-            for (int i = 0; i < FrameWidth; i++)
-                PriorityBuffer[i] = 0;
+            Array.Clear(PriorityBuffer, 0, FrameWidth);
 
             if (BackgroundEnabled == false)
             {
@@ -153,9 +153,7 @@
             if (SpritesEnabled == false)
                 return;
 
-            // clear inter-sprite priority buffer
-            for (int i = 0; i < FrameWidth; i++)
-                InterSpritePriorityBuffer[i] = 0;
+            Array.Clear(InterSpritePriorityBuffer, 0, FrameWidth);
 
             for (int i = 0; i < 64; i++)
             {
diff --git a/BizHawk.Emulation/Consoles/PC Engine/VDC.cs b/BizHawk.Emulation/Consoles/PC Engine/VDC.cs
index 357aaa1290..99c28c39d1 100644
--- a/BizHawk.Emulation/Consoles/PC Engine/VDC.cs	
+++ b/BizHawk.Emulation/Consoles/PC Engine/VDC.cs	
@@ -124,7 +124,7 @@ namespace BizHawk.Emulation.Consoles.TurboGrafx
                     break;
 case CR:
 //if (Registers[CR] == 0)
-Log.Note("CPU", "****************** WRITE TO CR: {0:X}", Registers[CR]);
+//Log.Note("CPU", "****************** WRITE TO CR: {0:X}", Registers[CR]);
 break;
                 case BXR:
                     Registers[BXR] &= 0x3FF;
@@ -132,7 +132,7 @@ break;
                 case BYR:
                     Registers[BYR] &= 0x1FF;
                     BackgroundY = Registers[BYR];
-                    Console.WriteLine("Updating BYR to {0} at scanline {1}", BackgroundY, ScanLine);
+                    //Console.WriteLine("Updating BYR to {0} at scanline {1}", BackgroundY, ScanLine);
                     break;
                 case HDR: // Horizontal Display Register - update framebuffer size
                     FrameWidth = RequestedFrameWidth;
diff --git a/BizHawk.Emulation/Consoles/PC Engine/VPC.cs b/BizHawk.Emulation/Consoles/PC Engine/VPC.cs
index df461fc0fa..d2d6e7484a 100644
--- a/BizHawk.Emulation/Consoles/PC Engine/VPC.cs	
+++ b/BizHawk.Emulation/Consoles/PC Engine/VPC.cs	
@@ -221,8 +221,7 @@ namespace BizHawk.Emulation.Consoles.TurboGrafx
         private void InitializeScanLine(int scanline)
         {
             // Clear priority buffer
-            for (int i = 0; i < FrameWidth; i++)
-                PriorityBuffer[i] = 0;
+            Array.Clear(PriorityBuffer, 0, FrameWidth);
 
             // Initialize scanline to background color
             for (int i = 0; i < FrameWidth; i++)
@@ -272,8 +271,7 @@ namespace BizHawk.Emulation.Consoles.TurboGrafx
                 return;
 
             // clear inter-sprite priority buffer
-            for (int i = 0; i < FrameWidth; i++)
-                InterSpritePriorityBuffer[i] = 0;
+            Array.Clear(InterSpritePriorityBuffer, 0, FrameWidth);
 
             for (int i = 0; i < 64; i++)
             {
diff --git a/BizHawk.Emulation/Consoles/Sega/SMS/Compat.txt b/BizHawk.Emulation/Consoles/Sega/SMS/Compat.txt
index e4cb40f02a..bae94f3eb8 100644
--- a/BizHawk.Emulation/Consoles/Sega/SMS/Compat.txt
+++ b/BizHawk.Emulation/Consoles/Sega/SMS/Compat.txt
@@ -3,16 +3,9 @@
 * CodeMasters games use a custom mapper and special video modes (both implemented)
    + Fantastic Dizzy crashes shortly after starting a new game. Investigating.
 
-* F16 Fighting Falcon uses old SG-1000 video mode, and doesn't work on a GG/Genesis either.
-
-That said.. I will fix CodeMasters games and F16 Fighting Falcon eventually, and add full
-SG-1000 support, it's just not the high priority currently.
-
-* Raster effects are sometimes on the wrong line... but it's correct 99% of the time... :|
-  Update: I think this is a timing issue resulting in latching/rendering at the wrong part 
-  of a scanline. I should play with this timing.
+* F16 Fighting Falcon uses old SG-1000 video mode.
 
 ======= Game Gear compatibility issues =======
 
-* Axe Battler is broken.
-* "SEGA" logo audio sample plays at low rate in Sonic & Tails.
\ No newline at end of file
+* Outrun has raster effect on the wrong line. I've been able to modify interrupt code to
+  fix it, but so far, not without breaking other games.
\ No newline at end of file
diff --git a/BizHawk.Emulation/Consoles/Sega/SMS/SMS.cs b/BizHawk.Emulation/Consoles/Sega/SMS/SMS.cs
index e8930a0c87..4159ac5aa9 100644
--- a/BizHawk.Emulation/Consoles/Sega/SMS/SMS.cs
+++ b/BizHawk.Emulation/Consoles/Sega/SMS/SMS.cs
@@ -8,12 +8,10 @@ using BizHawk.Emulation.Sound;
 /*****************************************************
 
   VDP:
-  + Double Size Sprites
   + HCounter
   + Old TMS video modes (SG-1000)
   
   GENERAL:
-  + Debug some GameGear game issues.
   + Port 3F emulation (Japanese BIOS)
   + Try to clean up the organization of the source code. 
   + SG-1000 support
@@ -82,7 +80,7 @@ namespace BizHawk.Emulation.Consoles.Sega
             Cpu.ReadHardware = ReadPort;
             Cpu.WriteHardware = WritePort;
 
-            Vdp = new VDP(IsGameGear ? VdpMode.GameGear : VdpMode.SMS, DisplayType);
+            Vdp = new VDP(Cpu, IsGameGear ? VdpMode.GameGear : VdpMode.SMS, DisplayType);
             PSG = new SN76489();
             YM2413 = new YM2413();
             SoundMixer = new SoundMixer(PSG, YM2413);
@@ -98,7 +96,7 @@ namespace BizHawk.Emulation.Consoles.Sega
         {
             Cpu.Reset();
             Cpu.RegisterSP = 0xDFF0;
-            Vdp = new VDP(Vdp.VdpMode, DisplayType);
+            Vdp = new VDP(Cpu, Vdp.VdpMode, DisplayType);
             PSG.Reset();
             YM2413.Reset();
             SystemRam = new byte[0x2000];
@@ -140,8 +138,8 @@ namespace BizHawk.Emulation.Consoles.Sega
                 case 0x06: return 0xFF;
                 case 0x7E: return Vdp.ReadVLineCounter();
                 case 0x7F: break; // hline counter TODO
-                case 0xBE: return Vdp.ReadVram();
-                case 0xBF: Cpu.Interrupt = false; return Vdp.ReadVdpStatus();
+                case 0xBE: return Vdp.ReadData();
+                case 0xBF: return Vdp.ReadVdpStatus();
                 case 0xC0:
                 case 0xDC: return ReadControls1();
                 case 0xC1: 
@@ -169,42 +167,13 @@ namespace BizHawk.Emulation.Consoles.Sega
                 case 0x7F: PSG.WritePsgData(value, Cpu.TotalExecutedCycles); break;
                 case 0xBE: Vdp.WriteVdpData(value); break;
                 case 0xBD:
-                case 0xBF: Vdp.WriteVdpRegister(value); break;
+                case 0xBF: Vdp.WriteVdpControl(value); break;
                 case 0xF0: if (HasYM2413) YM2413.RegisterLatch = value; break;
                 case 0xF1: if (HasYM2413) YM2413.Write(value); break;
                 case 0xF2: if (HasYM2413) YM2413.DetectionValue = value; break;
             }
         }
 
-        private int lineIntLinesRemaining; 
-
-        private void ProcessFrameInterrupt()
-        {
-            if (Vdp.ScanLine == Vdp.BufferHeight+1)
-                Vdp.StatusByte |= 0x80;
-
-            if ((Vdp.StatusByte & 0x80) != 0 && Vdp.EnableFrameInterrupts)
-                Cpu.Interrupt = true;
-        }
-
-        private void ProcessLineInterrupt()
-        {
-            if (Vdp.ScanLine <= Vdp.BufferHeight)
-            {
-                if (lineIntLinesRemaining-- <= 0)
-                {
-                    if (Vdp.EnableLineInterrupts)
-                    {
-                        Cpu.Interrupt = true;
-                    }
-                    lineIntLinesRemaining = Vdp.Registers[0x0A];
-                }
-                return;
-            }
-            // else we're outside the active display period
-            lineIntLinesRemaining = Vdp.Registers[0x0A];
-        }
-
         public void FrameAdvance(bool render)
         {
             Controller.FrameNumber = Frame++;
@@ -213,18 +182,7 @@ namespace BizHawk.Emulation.Consoles.Sega
             if (IsGameGear == false)
                 Cpu.NonMaskableInterrupt = Controller["Pause"];
 
-            for (Vdp.ScanLine = 0; Vdp.ScanLine < scanlinesPerFrame; Vdp.ScanLine++)
-            {
-                ProcessFrameInterrupt();
-                ProcessLineInterrupt();
-
-                Vdp.RenderCurrentScanline(render);
-
-                Cpu.ExecuteCycles(IPeriod);
-
-                if (Vdp.ScanLine == scanlinesPerFrame-1)
-                    Vdp.RenderBlankingRegions();
-            }
+            Vdp.ExecFrame(render);
             PSG.EndFrame(Cpu.TotalExecutedCycles);
         }
 
diff --git a/BizHawk.Emulation/Consoles/Sega/SMS/VDP.Mode4.cs b/BizHawk.Emulation/Consoles/Sega/SMS/VDP.Mode4.cs
new file mode 100644
index 0000000000..81568c0acb
--- /dev/null
+++ b/BizHawk.Emulation/Consoles/Sega/SMS/VDP.Mode4.cs
@@ -0,0 +1,251 @@
+using System;
+
+// Contains rendering functions for TMS9918 Mode 4.
+
+namespace BizHawk.Emulation.Consoles.Sega
+{
+    public partial class VDP
+    {
+        internal void RenderBackgroundCurrentLine()
+        {
+            if (DisplayOn == false)
+            {
+                for (int x = 0; x < 256; x++)
+                    FrameBuffer[(ScanLine * 256) + x] = BackdropColor;
+                return;
+            }
+
+            // Clear the priority buffer for this scanline
+            Array.Clear(ScanlinePriorityBuffer, 0, 256);
+
+            int mapBase = NameTableBase;
+
+            int vertOffset = ScanLine + Registers[9];
+            if (FrameHeight == 192)
+            {
+                if (vertOffset >= 224)
+                    vertOffset -= 224;
+            }
+            else
+            {
+                if (vertOffset >= 256)
+                    vertOffset -= 256;
+            }
+            byte horzOffset = (HorizScrollLock && ScanLine < 16) ? (byte)0 : Registers[8];
+
+            int yTile = vertOffset / 8;
+
+            for (int xTile = 0; xTile < 32; xTile++)
+            {
+                if (xTile == 24 && VerticalScrollLock)
+                {
+                    vertOffset = ScanLine;
+                    yTile = vertOffset / 8;
+                }
+
+                byte PaletteBase = 0;
+                int tileInfo = VRAM[mapBase + ((yTile * 32) + xTile) * 2] | (VRAM[mapBase + (((yTile * 32) + xTile) * 2) + 1] << 8);
+                int tileNo = tileInfo & 0x01FF;
+                if ((tileInfo & 0x800) != 0)
+                    PaletteBase = 16;
+                bool Priority = (tileInfo & 0x1000) != 0;
+                bool VFlip = (tileInfo & 0x400) != 0;
+                bool HFlip = (tileInfo & 0x200) != 0;
+
+                int yOfs = vertOffset & 7;
+                if (VFlip)
+                    yOfs = 7 - yOfs;
+
+                if (HFlip == false)
+                {
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 0] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 1] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 2] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 3] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 4] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 5] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 6] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 7] + PaletteBase];
+
+                    if (Priority)
+                    {
+                        horzOffset -= 8;
+                        for (int k = 0; k < 8; k++)
+                        {
+                            if (PatternBuffer[(tileNo * 64) + (yOfs * 8) + k] != 0)
+                                ScanlinePriorityBuffer[horzOffset] = 1;
+                            horzOffset++;
+                        }
+                    }
+                }
+                else // Flipped Horizontally
+                {
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 7] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 6] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 5] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 4] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 3] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 2] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 1] + PaletteBase];
+                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 0] + PaletteBase];
+
+                    if (Priority)
+                    {
+                        horzOffset -= 8;
+                        for (int k = 7; k >= 0; k--)
+                        {
+                            if (PatternBuffer[(tileNo * 64) + (yOfs * 8) + k] != 0)
+                                ScanlinePriorityBuffer[horzOffset] = 1;
+                            horzOffset++;
+                        }
+                    }
+                }
+            }
+        }
+
+        internal void RenderSpritesCurrentLine()
+        {
+            if (DisplayOn == false) return;
+            int SpriteBase = SpriteAttributeTableBase;
+            int SpriteHeight = Enable8x16Sprites ? 16 : 8;
+
+            // Clear the sprite collision buffer for this scanline
+            Array.Clear(SpriteCollisionBuffer, 0, 256);
+
+            // 208 is a special terminator sprite (in 192-line mode). Lets find it...
+            int TerminalSprite = 64;
+            if (FrameHeight == 192)
+                for (int i = 0; i < 64; i++)
+                {
+                    if (VRAM[SpriteBase + i] == 208)
+                    {
+                        TerminalSprite = i;
+                        break;
+                    }
+                }
+
+            // Loop through these sprites and render the current scanline
+            int SpritesDrawnThisScanline = 0;
+            for (int i = TerminalSprite - 1; i >= 0; i--)
+            {
+                if (SpritesDrawnThisScanline >= 8)
+                    StatusByte |= 0x40; // Set Overflow bit
+
+                int x = VRAM[SpriteBase + 0x80 + (i * 2)];
+                if (ShiftSpritesLeft8Pixels)
+                    x -= 8;
+
+                int y = VRAM[SpriteBase + i] + 1;
+                if (y >= (Enable8x16Sprites ? 240 : 248)) y -= 256;
+
+                if (y + SpriteHeight <= ScanLine || y > ScanLine)
+                    continue;
+
+                int tileNo = VRAM[SpriteBase + 0x80 + (i * 2) + 1];
+                if (Enable8x16Sprites)
+                    tileNo &= 0xFE;
+                tileNo += SpriteTileBase;
+
+                int ys = ScanLine - y;
+
+                for (int xs = 0; xs < 8 && x + xs < 256; xs++)
+                {
+                    byte color = PatternBuffer[(tileNo * 64) + (ys * 8) + xs];
+                    if (color != 0 && x + xs >= 0 && ScanlinePriorityBuffer[x + xs] == 0)
+                    {
+                        FrameBuffer[(ys + y) * 256 + x + xs] = Palette[(color + 16)];
+                        if (SpriteCollisionBuffer[x + xs] != 0)
+                            StatusByte |= 0x20; // Set Collision bit
+                        SpriteCollisionBuffer[x + xs] = 1;
+                    }
+                }
+                SpritesDrawnThisScanline++;
+            }
+        }
+
+        internal void RenderSpritesCurrentLineDoubleSize()
+        {
+            if (DisplayOn == false) return;
+            int SpriteBase = SpriteAttributeTableBase;
+            int SpriteHeight = Enable8x16Sprites ? 16 : 8;
+
+            // Clear the sprite collision buffer for this scanline
+            Array.Clear(SpriteCollisionBuffer, 0, 256); 
+
+            // 208 is a special terminator sprite (in 192-line mode). Lets find it...
+            int TerminalSprite = 64;
+            if (FrameHeight == 192)
+                for (int i = 0; i < 64; i++)
+                {
+                    if (VRAM[SpriteBase + i] == 208)
+                    {
+                        TerminalSprite = i;
+                        break;
+                    }
+                }
+
+            // Loop through these sprites and render the current scanline
+            int SpritesDrawnThisScanline = 0;
+            for (int i = TerminalSprite - 1; i >= 0; i--)
+            {
+                if (SpritesDrawnThisScanline >= 8)
+                    StatusByte |= 0x40; // Set Overflow bit
+
+                int x = VRAM[SpriteBase + 0x80 + (i * 2)];
+                if (ShiftSpritesLeft8Pixels)
+                    x -= 8;
+
+                int y = VRAM[SpriteBase + i] + 1;
+                if (y >= (Enable8x16Sprites ? 240 : 248)) y -= 256;
+
+                if (y + (SpriteHeight*2) <= ScanLine || y > ScanLine)
+                    continue;
+
+                int tileNo = VRAM[SpriteBase + 0x80 + (i * 2) + 1];
+                if (Enable8x16Sprites)
+                    tileNo &= 0xFE;
+                tileNo += SpriteTileBase;
+
+                int ys = ScanLine - y;
+
+                for (int xs = 0; xs < 16 && x + xs < 256; xs++)
+                {
+                    byte color = PatternBuffer[(tileNo * 64) + ((ys/2) * 8) + (xs/2)];
+                    if (color != 0 && x + xs >= 0 && ScanlinePriorityBuffer[x + xs] == 0)
+                    {
+                        FrameBuffer[(ys + y) * 256 + x + xs] = Palette[(color + 16)];
+                        if (SpriteCollisionBuffer[x + xs] != 0)
+                            StatusByte |= 0x20; // Set Collision bit
+                        SpriteCollisionBuffer[x + xs] = 1;
+                    }
+                }
+                SpritesDrawnThisScanline++;
+            }
+        }
+
+        /// <summary>
+        /// Performs render buffer blanking. This includes the left-column blanking as well as Game Gear blanking if requested.
+        /// Should be called at the end of the frame.
+        /// </summary>
+        internal void RenderBlankingRegions()
+        {
+            int blankingColor = Palette[BackdropColor];
+
+            if (LeftBlanking)
+            {
+                for (int y = 0; y < FrameHeight; y++)
+                {
+                    for (int x = 0; x < 8; x++)
+                        FrameBuffer[(y * 256) + x] = blankingColor;
+                }
+            }
+
+            if (mode == VdpMode.GameGear)
+            {
+                for (int y = 0; y < 144; y++)
+                    for (int x = 0; x < 160; x++)
+                        GameGearFrameBuffer[(y * 160) + x] = FrameBuffer[((y + 24) * 256) + x + 48];
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/Consoles/Sega/SMS/VDP.cs b/BizHawk.Emulation/Consoles/Sega/SMS/VDP.cs
index 8460f2f7a7..69729cc4bf 100644
--- a/BizHawk.Emulation/Consoles/Sega/SMS/VDP.cs
+++ b/BizHawk.Emulation/Consoles/Sega/SMS/VDP.cs
@@ -1,25 +1,14 @@
 using System;
 using System.Globalization;
 using System.IO;
+using BizHawk.Emulation.CPUs.Z80;
 
 namespace BizHawk.Emulation.Consoles.Sega
 {
-    public enum VdpCommand
-    {
-        VramRead,
-        VramWrite,
-        RegisterWrite,
-        CramWrite
-    }
-    
-    public enum VdpMode
-    {
-        SMS,
-        GameGear
-    }
+    public enum VdpMode { SMS, GameGear }
 
     /// <summary>
-    /// Emulates the Texas Instruments TMS9918(A) VDP.
+    /// Emulates the Texas Instruments TMS9918 VDP.
     /// </summary>
     public sealed partial class VDP : IVideoProvider
     {
@@ -29,80 +18,79 @@ namespace BizHawk.Emulation.Consoles.Sega
         public byte[] Registers = new byte[] { 0x06, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0xF0, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00 };
         public byte StatusByte;
 
-        private bool vdpWaitingForLatchByte = true;
-        private byte vdpLatch;
-        private byte vdpBuffer;
-        private ushort vdpAddress;
+        private bool VdpWaitingForLatchByte = true;
+        private byte VdpLatch;
+        private byte VdpBuffer;
+        private ushort VdpAddress;
         private VdpCommand vdpCommand;
-        private ushort vdpAddressClamp;
+
+        private bool VIntPending;
+        private bool HIntPending;
 
         private VdpMode mode;
         public VdpMode VdpMode { get { return mode; } }
+        private DisplayType DisplayType = DisplayType.NTSC;
+        private Z80A Cpu;
 
         public int ScanLine;
-
         private int FrameHeight = 192;
-
         public int[] FrameBuffer = new int[256*192];
         public int[] GameGearFrameBuffer = new int[160*144];
 
-        private DisplayType DisplayType = DisplayType.NTSC;
-
-        // preprocessed state assist stuff.
-        public int[] Palette = new int[32];
-
-        private static readonly byte[] SMSPalXlatTable = { 0, 85, 170, 255 };
-        private static readonly byte[] GGPalXlatTable = { 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255 };
-
+        public bool Mode2Bit                { get { return (Registers[0] & 2) > 0; } }
+        public bool Mode4Bit                { get { return (Registers[0] & 4) > 0; } }
         public bool ShiftSpritesLeft8Pixels { get { return (Registers[0] & 8) > 0; } }
         public bool EnableLineInterrupts    { get { return (Registers[0] & 16) > 0; } }
         public bool LeftBlanking            { get { return (Registers[0] & 32) > 0; } }
         public bool HorizScrollLock         { get { return (Registers[0] & 64) > 0; } }
         public bool VerticalScrollLock      { get { return (Registers[0] & 128) > 0; } }
-        public bool DisplayOn               { get { return (Registers[1] & 64) > 0; } }
-        public bool EnableFrameInterrupts   { get { return (Registers[1] & 32) > 0; } }
+        public bool EnableDoubledSprites    { get { return (Registers[1] & 1) > 0; } }
         public bool Enable8x16Sprites       { get { return (Registers[1] & 2) > 0; } }
-        public byte BackdropColor           { get { return (byte) (16 + (Registers[7] & 15)); } }
+        public bool EnableFrameInterrupts   { get { return (Registers[1] & 32) > 0; } }
+        public bool DisplayOn               { get { return (Registers[1] & 64) > 0; } }
         public int SpriteAttributeTableBase { get { return ((Registers[5] >> 1) << 8) & 0x3FFF; } }
         public int SpriteTileBase           { get { return (Registers[6] & 4) > 0 ? 256: 0; } }
-        
-        public int NameTableBase 
-        { 
-            get
-            {
-                if (FrameHeight == 192) 
-                    return 1024 * (Registers[2] & 0x0E);
-                return (1024 * (Registers[2] & 0x0C)) + 0x0700;
-            } 
-        }
+        public byte BackdropColor           { get { return (byte)(16 + (Registers[7] & 15)); } }
 
+        private int NameTableBase;
+        
+        // preprocessed state assist stuff.
+        public int[] Palette = new int[32];
         public byte[] PatternBuffer = new byte[0x8000];
 
         private byte[] ScanlinePriorityBuffer = new byte[256];
         private byte[] SpriteCollisionBuffer = new byte[256];
 
-        public VDP(VdpMode mode, DisplayType displayType)
+        private static readonly byte[] SMSPalXlatTable = { 0, 85, 170, 255 };
+        private static readonly byte[] GGPalXlatTable = { 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255 };
+
+        public VDP(Z80A cpu, VdpMode mode, DisplayType displayType)
         {
+            Cpu = cpu;
             this.mode = mode;
             if (mode == VdpMode.SMS) CRAM = new byte[32];
             if (mode == VdpMode.GameGear) CRAM = new byte[64];
             DisplayType = displayType;
+            NameTableBase = CalcNameTableBase();
         }
 
-        public byte ReadVram()
+        public byte ReadData()
         {
-            vdpWaitingForLatchByte = true;
-            byte value = vdpBuffer;
-            vdpBuffer = VRAM[vdpAddress & vdpAddressClamp];
-            vdpAddress++;
+            VdpWaitingForLatchByte = true;
+            byte value = VdpBuffer;
+            VdpBuffer = VRAM[VdpAddress & 0x3FFF];
+            VdpAddress++;
             return value;
         }
 
         public byte ReadVdpStatus()
         {
-            vdpWaitingForLatchByte = true;
+            VdpWaitingForLatchByte = true;
             byte returnValue = StatusByte;
             StatusByte &= 0x1F;
+            HIntPending = false;
+            VIntPending = false;
+            Cpu.Interrupt = false;
             return returnValue;
         }
 
@@ -120,63 +108,57 @@ namespace BizHawk.Emulation.Consoles.Sega
             }
         }
 
-        public void WriteVdpRegister(byte value)
+        public void WriteVdpControl(byte value)
         {
-            if (vdpWaitingForLatchByte)
+            if (VdpWaitingForLatchByte)
             {
-                vdpLatch = value;
-                vdpWaitingForLatchByte = false;
-                vdpAddress = (ushort)((vdpAddress & 0xFF00) | value);
+                VdpLatch = value;
+                VdpWaitingForLatchByte = false;
+                VdpAddress = (ushort)((VdpAddress & 0xFF00) | value);
                 return;
             }
 
-            vdpWaitingForLatchByte = true;
+            VdpWaitingForLatchByte = true;
+            VdpAddress = (ushort)(((value & 63) << 8) | VdpLatch);
             switch (value & 0xC0)
             {
                 case 0x00: // read VRAM
                     vdpCommand = VdpCommand.VramRead;
-                    vdpAddressClamp = 0x3FFF;
-                    vdpAddress = (ushort)(((value & 63) << 8) | vdpLatch);
-                    vdpBuffer = VRAM[vdpAddress & vdpAddressClamp];
-                    vdpAddress++;
+                    VdpBuffer = VRAM[VdpAddress & 0x3FFF];
+                    VdpAddress++;
                     break;
                 case 0x40: // write VRAM
                     vdpCommand = VdpCommand.VramWrite;
-                    vdpAddressClamp = 0x3FFF;
-                    vdpAddress = (ushort)(((value & 63) << 8) | vdpLatch);
                     break;
                 case 0x80: // VDP register write
+                    vdpCommand = VdpCommand.RegisterWrite;
                     int reg = value & 0x0F;
-                    Registers[reg] = vdpLatch;
-                    if (reg == 1 || reg == 2)
-                        CheckVideoMode();
+                    WriteRegister(reg, VdpLatch);
                     break;
                 case 0xC0: // write CRAM / modify palette
                     vdpCommand = VdpCommand.CramWrite;
-                    vdpAddressClamp = (byte) (mode == VdpMode.SMS ? 0x1F : 0x3F);
-                    vdpAddress = (ushort)(((value & 63) << 8) | vdpLatch);
                     break;
             }
         }
 
         public void WriteVdpData(byte value)
         {
-            vdpWaitingForLatchByte = true;
-            vdpBuffer = value;
+            VdpWaitingForLatchByte = true;
+            VdpBuffer = value;
             if (vdpCommand == VdpCommand.CramWrite)
             {
                 // Write Palette / CRAM
-                CRAM[vdpAddress & vdpAddressClamp] = value;
-                vdpAddress++;
+                int mask = VdpMode == VdpMode.SMS ? 0x1F : 0x3F;
+                CRAM[VdpAddress & mask] = value;
                 UpdatePrecomputedPalette();
             }
             else
             {
                 // Write VRAM and update pre-computed pattern buffer. 
-                UpdatePatternBuffer((ushort)(vdpAddress & vdpAddressClamp), value);
-                VRAM[vdpAddress & vdpAddressClamp] = value;
-                vdpAddress++;
+                UpdatePatternBuffer((ushort)(VdpAddress & 0x3FFF), value);
+                VRAM[VdpAddress & 0x3FFF] = value;
             }
+            VdpAddress++;
         }
 
         public void UpdatePrecomputedPalette()
@@ -191,8 +173,7 @@ namespace BizHawk.Emulation.Consoles.Sega
                     byte b = SMSPalXlatTable[(value & 0x30) >> 4];
                     Palette[i] = Colors.ARGB(r, g, b);
                 }
-            } else // GameGear
-            { 
+            } else { // GameGear
                 for (int i=0; i<32; i++)
                 {
                     ushort value = (ushort) ((CRAM[(i*2) + 1] << 8) | CRAM[(i*2) + 0]);
@@ -204,9 +185,16 @@ namespace BizHawk.Emulation.Consoles.Sega
             }
         }
 
+        public int CalcNameTableBase()
+        { 
+            if (FrameHeight == 192) 
+                return 1024 * (Registers[2] & 0x0E);
+            return (1024 * (Registers[2] & 0x0C)) + 0x0700;
+        }
+
         private void CheckVideoMode()
         {
-            if ((Registers[0] & 6) == 6) // if Mode4 and Mode2 set, then check extension modes
+            if (Mode4Bit && Mode2Bit) // if Mode4 and Mode2 set, then check extension modes
             {
                 switch (Registers[1] & 0x18)
                 {
@@ -214,34 +202,61 @@ namespace BizHawk.Emulation.Consoles.Sega
                     case 0x18: // 192-line mode
                         if (FrameHeight != 192)
                         {
+                            Console.WriteLine("Change video mode to 192-line Mode4");
                             FrameHeight = 192;
                             FrameBuffer = new int[256*192];
+                            NameTableBase = CalcNameTableBase();
                         }
                         break;
                     case 0x10: // 224-line mode
                         if (FrameHeight != 224)
                         {
+                            Console.WriteLine("Change video mode to 224-line Mode4");
                             FrameHeight = 224;
                             FrameBuffer = new int[256*224];
+                            NameTableBase = CalcNameTableBase();
                         }
                         break;
                     case 0x08: // 240-line mode
                         if (FrameHeight != 240)
                         {
+                            Console.WriteLine("Change video mode to 240-line Mode4");
                             FrameHeight = 240;
                             FrameBuffer = new int[256 * 240];
+                            NameTableBase = CalcNameTableBase();
                         }
                         break;
                 }
             } else { // default to standard 192-line mode4
                 if (FrameHeight != 192)
                 {
+                    Console.WriteLine("Change video mode to 192-line Mode4");
                     FrameHeight = 192;
                     FrameBuffer = new int[256*192];
+                    NameTableBase = CalcNameTableBase();
                 }
             }
         }
 
+        private void WriteRegister(int reg, byte data)
+        {
+            Registers[reg] = data;
+            switch(reg)
+            {
+                case 0: // Mode Control Register 1
+                    CheckVideoMode();
+                    Cpu.Interrupt = (EnableLineInterrupts && HIntPending);
+                    break;
+                case 1: // Mode Control Register 2
+                    CheckVideoMode();
+                    Cpu.Interrupt = (EnableFrameInterrupts && VIntPending);
+                    break;
+                case 2: // Name Table Base Address
+                    NameTableBase = CalcNameTableBase();
+                    break;
+            }
+        }
+
         private static readonly byte[] pow2 = {1, 2, 4, 8, 16, 32, 64, 128};
         
         private void UpdatePatternBuffer(ushort address, byte value)
@@ -259,6 +274,53 @@ namespace BizHawk.Emulation.Consoles.Sega
             }
         }
 
+        private int lineIntLinesRemaining;
+
+        private void ProcessFrameInterrupt()
+        {
+            if (ScanLine == FrameHeight + 1)
+            {
+                StatusByte |= 0x80;
+                VIntPending = true;
+            }
+
+            if (VIntPending && EnableFrameInterrupts)
+                Cpu.Interrupt = true;
+        }
+
+        private void ProcessLineInterrupt()
+        {
+            if (ScanLine <= FrameHeight)
+            {
+                if (lineIntLinesRemaining-- <= 0)
+                {
+                    HIntPending = true;
+                    if (EnableLineInterrupts)
+                        Cpu.Interrupt = true;
+                    lineIntLinesRemaining = Registers[0x0A];
+                }
+                return;
+            }
+            // else we're outside the active display period
+            lineIntLinesRemaining = Registers[0x0A];
+        }
+
+        public void ExecFrame(bool render)
+        {
+            int scanlinesPerFrame = DisplayType == DisplayType.NTSC ? 262 : 313;
+            for (ScanLine = 0; ScanLine < scanlinesPerFrame; ScanLine++)
+            {
+                RenderCurrentScanline(render);
+
+                ProcessFrameInterrupt();
+                ProcessLineInterrupt();
+
+                Cpu.ExecuteCycles(228);
+
+                if (ScanLine == scanlinesPerFrame - 1)
+                    RenderBlankingRegions();
+            }
+        }
         internal void RenderCurrentScanline(bool render)
         {
             if (ScanLine >= FrameHeight)
@@ -266,202 +328,21 @@ namespace BizHawk.Emulation.Consoles.Sega
 
             // TODO: make frameskip actually skip rendering
             RenderBackgroundCurrentLine();
-            RenderSpritesCurrentLine();
-        }
-
-        internal void RenderBackgroundCurrentLine()
-        {
-            if (DisplayOn == false)
-            {
-                for (int x = 0; x < 256; x++)
-                    FrameBuffer[(ScanLine*256) + x] = BackdropColor;
-                return;
-            }
-
-            // Clear the priority buffer for this scanline
-            for (int p = 0; p < 256; p++)
-                ScanlinePriorityBuffer[p] = 0;
-
-            int mapBase = NameTableBase;
-
-            int vertOffset = ScanLine + Registers[9];
-            if (FrameHeight == 192)
-            {
-                if (vertOffset >= 224)
-                    vertOffset -= 224;
-            } else
-            {
-                if (vertOffset >= 256)
-                    vertOffset -= 256;
-            }
-            byte horzOffset = (HorizScrollLock && ScanLine < 16) ? (byte) 0 : Registers[8];
-
-            int yTile = vertOffset/8;
-
-            for (int xTile = 0; xTile<32; xTile++)
-            {
-                if (xTile == 24 && VerticalScrollLock)
-                {
-                    vertOffset = ScanLine;
-                    yTile = vertOffset/8;
-                }
-                
-                byte PaletteBase = 0;
-                int tileInfo = VRAM[mapBase+((yTile*32) + xTile)*2] | (VRAM[mapBase+(((yTile*32) + xTile)*2) + 1]<<8);
-                int tileNo = tileInfo & 0x01FF;
-                if ((tileInfo & 0x800) != 0) 
-                    PaletteBase = 16;
-                bool Priority = (tileInfo & 0x1000) != 0;
-                bool VFlip = (tileInfo & 0x400) != 0;
-                bool HFlip = (tileInfo & 0x200) != 0;
-
-                int yOfs = vertOffset & 7;
-                if (VFlip) 
-                    yOfs = 7 - yOfs;
-
-                if (HFlip == false)
-                {
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 0] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 1] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 2] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 3] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 4] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 5] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 6] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 7] + PaletteBase];
-                    
-                    if (Priority)
-                    {
-                        horzOffset -= 8;
-                        for (int k = 0; k < 8; k++)
-                        {
-                            if (PatternBuffer[(tileNo * 64) + (yOfs * 8) + k] != 0)
-                                ScanlinePriorityBuffer[horzOffset] = 1;
-                            horzOffset++;
-                        }
-                    }
-                }
-                else // Flipped Horizontally
-                {
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 7] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 6] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 5] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 4] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 3] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 2] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 1] + PaletteBase];
-                    FrameBuffer[(ScanLine * 256) + horzOffset++] = Palette[PatternBuffer[(tileNo * 64) + (yOfs * 8) + 0] + PaletteBase];
-
-                    if (Priority)
-                    {
-                        horzOffset -= 8;
-                        for (int k = 7; k >= 0; k--)
-                        {
-                            if (PatternBuffer[(tileNo * 64) + (yOfs * 8) + k] != 0)
-                                ScanlinePriorityBuffer[horzOffset] = 1;
-                            horzOffset++;
-                        }
-                    }
-                }
-            }
-        }
-
-        internal void RenderSpritesCurrentLine()
-        {
-            if (DisplayOn == false) return;
-            int SpriteBase = SpriteAttributeTableBase;
-            int SpriteHeight = Enable8x16Sprites ? 16 : 8;
-
-            // Clear the sprite collision buffer for this scanline
-            for (int c = 0; c < 256; c++)
-                SpriteCollisionBuffer[c] = 0;
-
-            // 208 is a special terminator sprite (in 192-line mode). Lets find it...
-            int TerminalSprite = 64;
-            if (FrameHeight == 192)
-                for (int i = 0; i < 64; i++)
-                {
-                    if (VRAM[SpriteBase + i] == 208)
-                    {
-                        TerminalSprite = i;
-                        break;
-                    }
-                }
             
-            // Loop through these sprites and render the current scanline
-            int SpritesDrawnThisScanline = 0;
-            for (int i = TerminalSprite - 1; i >= 0; i--)
-            {
-                if (SpritesDrawnThisScanline >= 8)
-                    StatusByte |= 0x40; // Set Overflow bit
-
-                int x = VRAM[SpriteBase + 0x80 + (i*2)];
-                if (ShiftSpritesLeft8Pixels)
-                    x -= 8;
-
-                int y = VRAM[SpriteBase + i] + 1;
-                if (y >= (Enable8x16Sprites ? 240 : 248)) y -= 256;
-                 
-                if (y+SpriteHeight<=ScanLine || y > ScanLine)
-                    continue;
-
-                int tileNo = VRAM[SpriteBase + 0x80 + (i*2) + 1];
-                if (Enable8x16Sprites) 
-                    tileNo &= 0xFE;
-                tileNo += SpriteTileBase;
-
-                int ys = ScanLine - y;
-                
-                for (int xs = 0; xs<8 && x+xs < 256; xs++)
-                {
-                    byte color = PatternBuffer[(tileNo*64) + (ys*8) + xs];
-                    if (color != 0 && x+xs >= 0 && ScanlinePriorityBuffer[x + xs] == 0)
-                    {
-                        FrameBuffer[(ys + y)*256 + x + xs] = Palette[(color + 16)];
-                        if (SpriteCollisionBuffer[x + xs] != 0)
-                            StatusByte |= 0x20; // Set Collision bit
-                        SpriteCollisionBuffer[x + xs] = 1;
-                    }
-                }
-                SpritesDrawnThisScanline++;
-            }
-        }
-
-        /// <summary>
-        /// Performs render buffer blanking. This includes the left-column blanking as well as Game Gear blanking if requested.
-        /// Should be called at the end of the frame.
-        /// </summary>
-        public void RenderBlankingRegions()
-        {
-            int blankingColor = Palette[BackdropColor];
-
-            if (LeftBlanking)
-            {
-                for (int y=0; y<FrameHeight; y++)
-                {
-                    for (int x=0; x<8; x++)
-                        FrameBuffer[(y*256) + x] = blankingColor;
-                }
-            }
-
-            if (mode == VdpMode.GameGear)
-            {
-                for (int y = 0; y < 144; y++)
-                    for (int x = 0; x < 160; x++)
-                        GameGearFrameBuffer[(y*160) + x] = FrameBuffer[((y + 24)*256) + x + 48];
-            }
+            if (EnableDoubledSprites)
+                RenderSpritesCurrentLineDoubleSize();
+            else
+                RenderSpritesCurrentLine();
         }
 
         public void SaveStateText(TextWriter writer)
         {
             writer.WriteLine("[VDP]");
-            writer.WriteLine("Mode " + Enum.GetName(typeof(VdpMode), VdpMode));
             writer.WriteLine("StatusByte {0:X2}", StatusByte);
-            writer.WriteLine("WaitingForLatchByte {0}", vdpWaitingForLatchByte);
-            writer.WriteLine("Latch {0:X2}", vdpLatch);
-            writer.WriteLine("ReadBuffer {0:X2}", vdpBuffer);
-            writer.WriteLine("VdpAddress {0:X4}", vdpAddress);
-            writer.WriteLine("VdpAddressMask {0:X2}", vdpAddressClamp);
+            writer.WriteLine("WaitingForLatchByte {0}", VdpWaitingForLatchByte);
+            writer.WriteLine("Latch {0:X2}", VdpLatch);
+            writer.WriteLine("ReadBuffer {0:X2}", VdpBuffer);
+            writer.WriteLine("VdpAddress {0:X4}", VdpAddress);
             writer.WriteLine("Command " + Enum.GetName(typeof(VdpCommand), vdpCommand));
 
             writer.Write("Registers ");
@@ -485,15 +366,13 @@ namespace BizHawk.Emulation.Consoles.Sega
                 if (args[0] == "StatusByte")
                     StatusByte = byte.Parse(args[1], NumberStyles.HexNumber);
                 else if (args[0] == "WaitingForLatchByte")
-                    vdpWaitingForLatchByte = bool.Parse(args[1]);
+                    VdpWaitingForLatchByte = bool.Parse(args[1]);
                 else if (args[0] == "Latch")
-                    vdpLatch = byte.Parse(args[1], NumberStyles.HexNumber);
+                    VdpLatch = byte.Parse(args[1], NumberStyles.HexNumber);
                 else if (args[0] == "ReadBuffer")
-                    vdpBuffer = byte.Parse(args[1], NumberStyles.HexNumber);
+                    VdpBuffer = byte.Parse(args[1], NumberStyles.HexNumber);
                 else if (args[0] == "VdpAddress")
-                    vdpAddress = ushort.Parse(args[1], NumberStyles.HexNumber);
-                else if (args[0] == "VdpAddressMask")
-                    vdpAddressClamp = ushort.Parse(args[1], NumberStyles.HexNumber);
+                    VdpAddress = ushort.Parse(args[1], NumberStyles.HexNumber);
                 else if (args[0] == "Command")
                     vdpCommand = (VdpCommand) Enum.Parse(typeof (VdpCommand), args[1]);
                 else if (args[0] == "Registers")
@@ -513,17 +392,17 @@ namespace BizHawk.Emulation.Consoles.Sega
                 else 
                     Console.WriteLine("Skipping unrecognized identifier "+args[0]);
             }
-            CheckVideoMode();
+            for (int i=0; i<Registers.Length; i++)
+                WriteRegister(i, Registers[i]);
         }
 
         public void SaveStateBinary(BinaryWriter writer)
         {
             writer.Write(StatusByte);
-            writer.Write(vdpWaitingForLatchByte);
-            writer.Write(vdpLatch);
-            writer.Write(vdpBuffer);
-            writer.Write(vdpAddress);
-            writer.Write(vdpAddressClamp);
+            writer.Write(VdpWaitingForLatchByte);
+            writer.Write(VdpLatch);
+            writer.Write(VdpBuffer);
+            writer.Write(VdpAddress);
             writer.Write((byte)vdpCommand);
             writer.Write(Registers);
             writer.Write(CRAM);
@@ -533,11 +412,10 @@ namespace BizHawk.Emulation.Consoles.Sega
         public void LoadStateBinary(BinaryReader reader)
         {
             StatusByte = reader.ReadByte();
-            vdpWaitingForLatchByte = reader.ReadBoolean();
-            vdpLatch = reader.ReadByte();
-            vdpBuffer = reader.ReadByte();
-            vdpAddress = reader.ReadUInt16();
-            vdpAddressClamp = reader.ReadUInt16();
+            VdpWaitingForLatchByte = reader.ReadBoolean();
+            VdpLatch = reader.ReadByte();
+            VdpBuffer = reader.ReadByte();
+            VdpAddress = reader.ReadUInt16();
             vdpCommand = (VdpCommand) Enum.ToObject(typeof(VdpCommand), reader.ReadByte());
             Registers = reader.ReadBytes(Registers.Length);
             CRAM = reader.ReadBytes(CRAM.Length);
@@ -545,7 +423,8 @@ namespace BizHawk.Emulation.Consoles.Sega
             UpdatePrecomputedPalette();
             for (ushort i = 0; i < VRAM.Length; i++)
                 UpdatePatternBuffer(i, VRAM[i]);
-            CheckVideoMode();
+            for (int i = 0; i < Registers.Length; i++)
+                WriteRegister(i, Registers[i]);
         }
 
         public int[] GetVideoBuffer()
@@ -567,5 +446,13 @@ namespace BizHawk.Emulation.Consoles.Sega
         {
             get { return Palette[BackdropColor]; }
         }
+
+        enum VdpCommand
+        {
+            VramRead,
+            VramWrite,
+            RegisterWrite,
+            CramWrite
+        }
     }
 }
\ No newline at end of file
diff --git a/BizHawk.Emulation/Database/Database.cs b/BizHawk.Emulation/Database/Database.cs
index ebf421af83..63542b2e6f 100644
--- a/BizHawk.Emulation/Database/Database.cs
+++ b/BizHawk.Emulation/Database/Database.cs
@@ -46,7 +46,7 @@ namespace BizHawk
                         Game.System = items[3];
                         Game.MetaData = items.Length >= 6 ? items[5] : null;
                         db[Game.CRC32] = Game;
-                    } catch (Exception e)
+                    } catch (Exception)
                     {
                         Console.WriteLine("Error parsing database entry: "+line);
                     }
diff --git a/BizHawk.MultiClient/BizHawk.MultiClient.csproj b/BizHawk.MultiClient/BizHawk.MultiClient.csproj
index 4680f61f88..3e185f0810 100644
--- a/BizHawk.MultiClient/BizHawk.MultiClient.csproj
+++ b/BizHawk.MultiClient/BizHawk.MultiClient.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -6,7 +6,7 @@
     <ProductVersion>9.0.21022</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{DD448B37-BA3F-4544-9754-5406E8094723}</ProjectGuid>
-    <OutputType>Exe</OutputType>
+    <OutputType>WinExe</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>BizHawk.MultiClient</RootNamespace>
     <AssemblyName>BizHawk.MultiClient</AssemblyName>
@@ -121,7 +121,6 @@
       <Name>BizHawk.Util</Name>
     </ProjectReference>
   </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/BizHawk.Util/BizHawk.Util.csproj b/BizHawk.Util/BizHawk.Util.csproj
index 1824b8e56e..57e4abae6c 100644
--- a/BizHawk.Util/BizHawk.Util.csproj
+++ b/BizHawk.Util/BizHawk.Util.csproj
@@ -116,7 +116,6 @@
   <ItemGroup>
     <Content Include="7z\arch\Test.txt" />
   </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.