Initial commit 0.13.9.16

36 files changed, 8867 insertions, 0 deletions

diff --git a/src/fake86/adlib.c b/src/fake86/adlib.c
new file mode 100755
index 0000000..cf17584
--- /dev/null
+++ b/src/fake86/adlib.c
@@ -0,0 +1,240 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* adlib.c: very ugly Adlib OPL2 emulation for Fake86. very much a work in progress. :) */
+
+#include "config.h"
+#include <SDL/SDL.h>
+#include <stdint.h>
+#include <stdio.h>
+
+extern void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback);
+
+extern int32_t usesamplerate;
+
+double samprateadjust = 1.0;
+uint8_t optable[0x16] = { 0, 0, 0, 1, 1, 1, 255, 255, 0, 0, 0, 1, 1, 1, 255, 255, 0, 0, 0, 1, 1, 1 };
+uint16_t adlibregmem[0xFF], adlibaddr = 0;
+
+int8_t waveform[4][64] = {
+	{ 1, 8, 13, 20, 26, 31, 37, 41, 47, 49, 54, 58, 58, 62, 63, 63, 64, 63, 62, 61, 58, 55, 52, 47, 45, 38, 34, 27, 23, 17, 10, 4,-2,-8,-15,-21,-26,-34,-36,-42,-48,-51,-54,-59,-60,-62,-64,-65,-65,-63,-64,-61,-59,-56,-53,-48,-46,-39,-36,-28,-24,-17,-11,-6 },
+	{ 1, 8, 13, 20, 25, 32, 36, 42, 46, 50, 54, 57, 60, 61, 62, 64, 63, 65, 61, 61, 58, 55, 51, 49, 44, 38, 34, 28, 23, 16, 11, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ 1, 8, 13, 21, 25, 31, 36, 43, 45, 50, 54, 57, 59, 62, 63, 63, 63, 64, 63, 59, 59, 55, 52, 48, 44, 38, 34, 28, 23, 16, 10, 4, 2, 7, 14, 20, 26, 31, 36, 42, 45, 51, 54, 56, 60, 62, 62, 63, 65, 63, 62, 60, 58, 55, 52, 48, 44, 38, 34, 28, 23, 17, 10, 3 },
+	{ 1, 8, 13, 20, 26, 31, 36, 42, 46, 51, 53, 57, 60, 62, 61, 66, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 13, 21, 25, 32, 36, 41, 47, 50, 54, 56, 60, 62, 61, 67, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+};
+
+int8_t oplwave[4][256] = {
+	{
+		0, 1, 3, 4, 6, 7, 9, 11, 12, 14, 15, 17, 18, 20, 22, 23, 24, 26, 27, 29, 30, 31, 33, 34, 36, 37, 38, 40, 40, 42, 43, 44, 46, 46, 48, 49, 50, 51, 51, 53,
+		53, 54, 55, 56, 57, 57, 58, 59, 59, 60, 61, 61, 62, 62, 63, 63, 63, 64, 64, 64, 116, 116, 116, 116, 116, 116, 116, 116, 116, 64, 64, 64, 63, 63, 63, 62, 62, 61, 61, 60,
+		59, 59, 58, 57, 57, 56, 55, 54, 53, 53, 51, 51, 50, 49, 48, 46, 46, 44, 43, 42, 40, 40, 38, 37, 36, 34, 33, 31, 30, 29, 27, 26, 24, 23, 22, 20, 18, 17, 15, 14,
+		12, 11, 9, 7, 6, 4, 3, 1, 0, -1, -3, -4, -6, -7, -9, -11, -12, -14, -15, -17, -18, -20, -22, -23, -24, -26, -27, -29, -30, -31, -33, -34, -36, -37, -38, -40, -40, -42, -43, -44,
+		-46, -46, -48, -49, -50, -51, -51, -53, -53, -54, -55, -56, -57, -57, -58, -59, -59, -60, -61, -61, -62, -62, -63, -63, -63, -64, -64, -64, -116, -116, -116, -116, -116, -116, -116, -116, -116, -64, -64, -64,
+		-63, -63, -63, -62, -62, -61, -61, -60, -59, -59, -58, -57, -57, -56, -55, -54, -53, -53, -51, -51, -50, -49, -48, -46, -46, -44, -43, -42, -40, -40, -38, -37, -36, -34, -33, -31, -30, -29, -27, -26,
+		-24, -23, -22, -20, -18, -17, -15, -14, -12, -11, -9, -7, -6, -4, -3, -1
+	},
+
+	{
+		0, 1, 3, 4, 6, 7, 9, 11, 12, 14, 15, 17, 18, 20, 22, 23, 24, 26, 27, 29,30, 31, 33, 34, 36, 37, 38, 40, 40, 42, 43, 44, 46, 46, 48, 49, 50, 51, 51, 53,
+		53, 54, 55, 56, 57, 57, 58, 59, 59, 60, 61, 61, 62, 62, 63, 63, 63, 64, 64, 64, 116, 116, 116, 116, 116, 116, 116, 116, 116, 64, 64, 64, 63, 63, 63, 62, 62, 61, 61, 60,
+		59, 59, 58, 57, 57, 56, 55, 54, 53, 53, 51, 51, 50, 49, 48, 46, 46, 44, 43, 42, 40, 40, 38, 37, 36, 34, 33, 31, 30, 29, 27, 26, 24, 23, 22, 20, 18, 17, 15, 14,
+		12, 11, 9, 7, 6, 4, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	},
+
+
+	{
+		0, 1, 3, 4, 6, 7, 9, 11, 12, 14, 15, 17, 18, 20, 22, 23, 24, 26, 27, 29, 30, 31, 33, 34, 36, 37, 38, 40, 40, 42, 43, 44, 46, 46, 48, 49, 50, 51, 51, 53,
+		53, 54, 55, 56, 57, 57, 58, 59, 59, 60, 61, 61, 62, 62, 63, 63, 63, 64, 64, 64, 116, 116, 116, 116, 116, 116, 116, 116, 116, 64, 64, 64, 63, 63, 63, 62, 62, 61, 61, 60,
+		59, 59, 58, 57, 57, 56, 55, 54, 53, 53, 51, 51, 50, 49, 48, 46, 46, 44, 43, 42, 40, 40, 38, 37, 36, 34, 33, 31, 30, 29, 27, 26, 24, 23, 22, 20, 18, 17, 15, 14,
+		12, 11, 9, 7, 6, 4, 3, 1, 0, 1, 3, 4, 6, 7, 9, 11, 12, 14, 15, 17, 18, 20, 22, 23, 24, 26, 27, 29, 30, 31, 33, 34, 36, 37, 38, 40, 40, 42, 43, 44,
+		46, 46, 48, 49, 50, 51, 51, 53, 53, 54, 55, 56, 57, 57, 58, 59, 59, 60, 61, 61, 62, 62, 63, 63, 63, 64, 64, 64, 116, 116, 116, 116, 116, 116, 116, 116, 116, 64, 64, 64,
+		63, 63, 63, 62, 62, 61, 61, 60, 59, 59, 58, 57, 57, 56, 55, 54, 53, 53, 51, 51, 50, 49, 48, 46, 46, 44, 43, 42, 40, 40, 38, 37, 36, 34, 33, 31, 30, 29, 27, 26,
+		24, 23, 22, 20, 18, 17, 15, 14, 12, 11, 9, 7, 6, 4, 3, 1
+	},
+
+
+	{
+		0, 1, 3, 4, 6, 7, 9, 11, 12, 14, 15, 17, 18, 20, 22, 23, 24, 26, 27, 29, 30, 31, 33, 34, 36, 37, 38, 40, 40, 42, 43, 44, 46, 46, 48, 49, 50, 51, 51, 53,
+		53, 54, 55, 56, 57, 57, 58, 59, 59, 60, 61, 61, 62, 62, 63, 63, 63, 64, 64, 64, 116, 116, 116, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 4, 6, 7, 9, 11, 12, 14, 15, 17, 18, 20, 22, 23, 24, 26, 27, 29, 30, 31, 33, 34, 36, 37, 38, 40, 40, 42, 43, 44,
+		46, 46, 48, 49, 50, 51, 51, 53, 53, 54, 55, 56, 57, 57, 58, 59, 59, 60, 61, 61, 62, 62, 63, 63, 63, 64, 64, 64, 116, 116, 116, 116, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	}
+
+};
+
+uint8_t oplstep[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+struct structadlibop {
+	uint8_t wave;
+} adlibop[9][2];
+
+struct structadlibchan {
+	uint16_t freq;
+	double convfreq;
+	uint8_t keyon;
+	uint16_t octave;
+	uint8_t wavesel;
+} adlibch[9];
+
+double attacktable[16] = { 1.0003, 1.00025, 1.0002, 1.00015, 1.0001, 1.00009, 1.00008, 1.00007, 1.00006, 1.00005, 1.00004, 1.00003, 1.00002, 1.00001, 1.000005 }; //1.003, 1.05, 1.01, 1.015, 1.02, 1.025, 1.03, 1.035, 1.04, 1.045, 1.05, 1.055, 1.06, 1.065, 1.07, 1.075 };
+double decaytable[16] = { 0.99999, 0.999985, 0.99998, 0.999975, 0.99997, 0.999965, 0.99996, 0.999955, 0.99995, 0.999945, 0.99994, 0.999935, 0.99994, 0.999925, 0.99992, 0.99991 };
+double adlibenv[9], adlibdecay[9], adlibattack[9];
+uint8_t adlibdidattack[9], adlibpercussion = 0, adlibstatus = 0;
+
+uint16_t adlibport = 0x388;
+
+void outadlib (uint16_t portnum, uint8_t value) {
+	if (portnum==adlibport) {
+			adlibaddr = value;
+			return;
+		}
+	portnum = adlibaddr;
+	adlibregmem[portnum] = value;
+	switch (portnum) {
+			case 4: //timer control
+				if (value&0x80) {
+						adlibstatus = 0;
+						adlibregmem[4] = 0;
+					}
+				break;
+			case 0xBD:
+				if (value & 0x10) adlibpercussion = 1;
+				else adlibpercussion = 0;
+				break;
+		}
+	if ( (portnum >= 0x60) && (portnum <= 0x75) ) { //attack/decay
+			portnum &= 15;
+			adlibattack[portnum] = attacktable[15- (value>>4) ]*1.006;
+			adlibdecay[portnum] = decaytable[value&15];
+		}
+	else if ( (portnum >= 0xA0) && (portnum <= 0xB8) ) { //octave, freq, key on
+			portnum &= 15;
+			if (!adlibch[portnum].keyon && ( (adlibregmem[0xB0+portnum]>>5) &1) ) {
+					adlibdidattack[portnum] = 0;
+					adlibenv[portnum] = 0.0025;
+				}
+			adlibch[portnum].freq = adlibregmem[0xA0+portnum] | ( (adlibregmem[0xB0+portnum]&3) <<8);
+			adlibch[portnum].convfreq = ( (double) adlibch[portnum].freq * 0.7626459);
+			adlibch[portnum].keyon = (adlibregmem[0xB0+portnum]>>5) &1;
+			adlibch[portnum].octave = (adlibregmem[0xB0+portnum]>>2) &7;
+		}
+	else if ( (portnum >= 0xE0) && (portnum <= 0xF5) ) { //waveform select
+			portnum &= 15;
+			if (portnum<9) adlibch[portnum].wavesel = value&3;
+		}
+}
+
+uint8_t inadlib (uint16_t portnum) {
+	if (!adlibregmem[4]) adlibstatus = 0;
+	else adlibstatus = 0x80;
+	adlibstatus = adlibstatus + (adlibregmem[4]&1) *0x40 + (adlibregmem[4]&2) *0x10;
+	return (adlibstatus);
+}
+
+uint16_t adlibfreq (uint8_t chan) {
+	uint16_t tmpfreq;
+	if (!adlibch[chan].keyon) return (0);
+	tmpfreq = (uint16_t) adlibch[chan].convfreq;
+	switch (adlibch[chan].octave) {
+			case 0:
+				tmpfreq = tmpfreq >> 4;
+				break;
+			case 1:
+				tmpfreq = tmpfreq >> 3;
+				break;
+			case 2:
+				tmpfreq = tmpfreq >> 2;
+				break;
+			case 3:
+				tmpfreq = tmpfreq >> 1;
+				break;
+			case 5:
+				tmpfreq = tmpfreq << 1;
+				break;
+			case 6:
+				tmpfreq = tmpfreq << 2;
+				break;
+			case 7:
+				tmpfreq = tmpfreq << 3;
+		}
+
+	return (tmpfreq);
+}
+
+uint64_t fullstep, adlibstep[9];
+double adlibenv[9], adlibdecay[9], adlibattack[9];
+uint8_t adlibdidattack[9];
+
+extern SDL_AudioSpec wanted;
+int32_t adlibsample (uint8_t curchan) {
+	int32_t tempsample;
+	double tempstep;
+
+	if (adlibpercussion && (curchan>=6) && (curchan<=8) ) return (0);
+
+	fullstep = usesamplerate/adlibfreq (curchan);
+
+	tempsample = (int32_t) oplwave[adlibch[curchan].wavesel][ (uint8_t) ( (double) adlibstep[curchan]/ ( (double) fullstep/ (double) 256) ) ];
+	tempstep = adlibenv[curchan];
+	if (tempstep>1.0) tempstep = 1;
+	tempsample = (int32_t) ( (double) tempsample * tempstep * 2.0);
+
+	adlibstep[curchan]++;
+	if (adlibstep[curchan]>fullstep) adlibstep[curchan] = 0;
+	return (tempsample);
+}
+
+int16_t adlibgensample() {
+	uint8_t curchan;
+	int16_t adlibaccum;
+	adlibaccum = 0;
+	for (curchan=0; curchan<9; curchan++) {
+			if (adlibfreq (curchan) !=0) {
+					adlibaccum += (int16_t) adlibsample (curchan);
+				}
+		}
+	return (adlibaccum);
+}
+
+void tickadlib() {
+	uint8_t curchan;
+	for (curchan=0; curchan<9; curchan++) {
+			if (adlibfreq (curchan) !=0) {
+					if (adlibdidattack[curchan]) {
+							adlibenv[curchan] *= adlibdecay[curchan];
+						}
+					else {
+							adlibenv[curchan] *= adlibattack[curchan];
+							if (adlibenv[curchan]>=1.0) adlibdidattack[curchan] = 1;
+						}
+				}
+		}
+}
+
+void initadlib (uint16_t baseport) {
+	set_port_write_redirector (baseport, baseport + 1, &outadlib);
+	set_port_read_redirector (baseport, baseport + 1, &inadlib);
+}
diff --git a/src/fake86/ata.c b/src/fake86/ata.c
new file mode 100755
index 0000000..df3b50a
--- /dev/null
+++ b/src/fake86/ata.c
@@ -0,0 +1,123 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include "config.h"
+#ifdef DISK_CONTROLLER_ATA
+#include <stdint.h>
+#include <stdio.h>
+#include <memory.h>
+#include <string.h>
+
+uint8_t idATA[512];
+
+#define ATA_STATUS_ERROR 0x01
+#define ATA_STATUS_DRQ   0x08
+#define ATA_STATUS_SRV   0x10
+#define ATA_STATUS_FAULT 0x20
+#define ATA_STATUS_READY 0x40
+#define ATA_STATUS_BUSY  0x80
+
+#define flip16(x) ((x&255) | (x>>8))
+#define flip32(x) ((x>>24) | (((x>>16)&255)<<8) | (((x>>8)&255)<<16) | ((x&255)<<24))
+
+uint8_t statusreg = 0, errorreg = 0, drivesel = 0, databuf[512];
+uint16_t dataptr = 512;
+
+void bufclear() {
+	memset (databuf, 0, 512);
+}
+
+void bufcook() {
+	uint16_t i;
+	uint8_t cc;
+	for (i=0; i<512; i+=2) {
+			cc = databuf[i];
+			databuf[i] = databuf[i+1];
+			databuf[i+1] = cc;
+		}
+}
+
+void bufwrite8 (uint16_t bufpos, uint8_t value) {
+	databuf[bufpos] = value;
+}
+
+void bufwrite16 (uint16_t bufpos, uint16_t value) {
+	databuf[bufpos] = (uint8_t) value;
+	databuf[bufpos+1] = (uint8_t) (value>>8);
+}
+
+void flipstring (uint8_t *dest, uint8_t *src) {
+	uint16_t i;
+	uint8_t cc;
+	strcpy (dest, src);
+	for (i=0; i<strlen (dest); i+=2) {
+			cc = databuf[i];
+			databuf[i] = databuf[i+1];
+			databuf[i+1] = cc;
+		}
+}
+
+void cmdATA (uint8_t value) {
+	switch (value) {
+			case 0x91: //INITIALIZE DEVICE PARAMETERS
+				dataptr = 512;
+				break;
+			case 0xEC: //IDENTIFY
+				memset (&idATA, 0, sizeof (idATA) );
+				memcpy (databuf, &idATA, 512);
+				dataptr = 0;
+				break;
+		}
+}
+
+void outATA (uint16_t portnum, uint8_t value) {
+	//printf("[DEBUG] ATA port %Xh write: %02X\n", portnum, value);
+	//getch();
+	switch (portnum) {
+			case 0x1F6:
+				drivesel = (value >> 4) & 1;
+				break;
+			case 0x1F7: //command register
+				cmdATA (value);
+				break;
+		}
+}
+
+uint8_t inATA (uint16_t portnum) {
+	//if (portnum != 0x1F0) printf("[DEBUG] ATA port %Xh read\n", portnum);
+	//getch();
+	switch (portnum) {
+			case 0x1F0: //data read
+				if (dataptr < 512) {
+						//printf("%c", databuf[dataptr]);
+						return (databuf[dataptr++]);
+					}
+				else return (0);
+			case 0x1F1: //error register
+				if (drivesel == 1) return (1);
+				else return (0);
+			case 0x1F7: //status register
+				statusreg = ATA_STATUS_READY;
+				if (drivesel == 1) statusreg |= ATA_STATUS_ERROR;
+				if (dataptr < 512) statusreg |= ATA_STATUS_DRQ;
+				return (statusreg);
+		}
+	return (0);
+}
+#endif
diff --git a/src/fake86/audio.c b/src/fake86/audio.c
new file mode 100755
index 0000000..fb8c76b
--- /dev/null
+++ b/src/fake86/audio.c
@@ -0,0 +1,152 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* audio.c: functions to mix the audio channels, and handle SDL's audio interface. */
+
+#include "config.h"
+#include <SDL/SDL.h>
+#ifdef _WIN32
+#include <Windows.h>
+#include <process.h>
+#else
+#include <pthread.h>
+#endif
+#include <stdint.h>
+#include <stdio.h>
+#include <memory.h>
+#include "blaster.h"
+#include "audio.h"
+
+extern SDL_Surface *screen;
+struct wav_hdr_s wav_hdr;
+FILE *wav_file = NULL;
+
+SDL_AudioSpec wanted;
+int8_t audbuf[96000];
+int32_t audbufptr, usebuffersize, usesamplerate = AUDIO_DEFAULT_SAMPLE_RATE, latency = AUDIO_DEFAULT_LATENCY;
+uint8_t speakerenabled = 0;
+
+extern uint64_t gensamplerate, sampleticks, hostfreq;
+extern int16_t adlibgensample();
+extern int16_t speakergensample();
+extern int16_t getssourcebyte();
+extern int16_t getBlasterSample();
+extern uint8_t usessource;
+
+void create_output_wav (uint8_t *filename) {
+	printf ("Creating %s for audio logging... ", filename);
+	wav_file = fopen (filename, "wb");
+	if (wav_file == NULL) {
+			printf ("failed!\n");
+			return;
+		}
+	printf ("OK!\n");
+
+	wav_hdr.AudioFormat = 1; //PCM
+	wav_hdr.bitsPerSample = 8;
+	wav_hdr.blockAlign = 1;
+	wav_hdr.ChunkSize = sizeof (wav_hdr) - 4;
+	sprintf (&wav_hdr.WAVE[0], "WAVE");
+	sprintf (&wav_hdr.fmt[0], "fmt ");
+	wav_hdr.NumOfChan = 1;
+	wav_hdr.bytesPerSec = usesamplerate * (uint32_t) (wav_hdr.bitsPerSample >> 3) * (uint32_t) wav_hdr.NumOfChan;
+	sprintf (&wav_hdr.RIFF[0], "RIFF");
+	wav_hdr.Subchunk1Size = 16;
+	wav_hdr.SamplesPerSec = usesamplerate;
+	sprintf (&wav_hdr.Subchunk2ID[0], "data");
+	wav_hdr.Subchunk2Size = 0;
+	//fwrite((void *)&wav_hdr, 1, sizeof(wav_hdr), wav_file);
+}
+
+uint64_t doublesamplecount, cursampnum = 0, sampcount = 0, framecount = 0;
+uint8_t bmpfilename[256];
+
+void savepic() {
+	SDL_SaveBMP (screen, &bmpfilename[0]);
+}
+
+int8_t samps[2400];
+
+uint8_t audiobufferfilled() {
+	if (audbufptr >= usebuffersize) return(1);
+	return(0);
+}
+
+void tickaudio() {
+	int16_t sample;
+	if (audbufptr >= usebuffersize) return;
+	sample = adlibgensample() >> 4;
+	if (usessource) sample += getssourcebyte();
+	sample += getBlasterSample();
+	if (speakerenabled) sample += (speakergensample() >> 1);
+	if (audbufptr < sizeof(audbuf) ) audbuf[audbufptr++] = (uint8_t) ((uint16_t) sample+128);
+}
+
+extern uint64_t timinginterval;
+extern void inittiming();
+void fill_audio (void *udata, int8_t *stream, int len) {
+	memcpy (stream, audbuf, len);
+	memmove (audbuf, &audbuf[len], usebuffersize - len);
+
+	audbufptr -= len;
+	if (audbufptr < 0) audbufptr = 0;
+}
+
+void initaudio() {
+	printf ("Initializing audio stream... ");
+
+	if (usesamplerate < 4000) usesamplerate = 4000;
+	else if (usesamplerate > 96000) usesamplerate = 96000;
+	if (latency < 10) latency = 10;
+	else if (latency > 1000) latency = 1000;
+	audbufptr = usebuffersize = (usesamplerate / 1000) * latency;
+	gensamplerate = usesamplerate;
+	doublesamplecount = (uint32_t) ( (double) usesamplerate * (double) 0.01);
+
+	wanted.freq = usesamplerate;
+	wanted.format = AUDIO_U8;
+	wanted.channels = 1;
+	wanted.samples = (uint16_t) usebuffersize >> 1;
+	wanted.callback = (void *) fill_audio;
+	wanted.userdata = NULL;
+
+	if (SDL_OpenAudio (&wanted, NULL) <0) {
+			printf ("Error: %s\n", SDL_GetError() );
+			return;
+		}
+	else {
+			printf ("OK! (%lu Hz, %lu ms, %lu sample latency)\n", usesamplerate, latency, usebuffersize);
+		}
+
+	memset (audbuf, 128, sizeof (audbuf) );
+	audbufptr = usebuffersize;
+	//create_output_wav("fake86.wav");
+	SDL_PauseAudio (0);
+	return;
+}
+
+void killaudio() {
+	SDL_PauseAudio (1);
+
+	if (wav_file == NULL) return;
+	wav_hdr.ChunkSize = wav_hdr.Subchunk2Size + sizeof(wav_hdr) - 8;
+	fseek(wav_file, 0, SEEK_SET);
+	fwrite((void *)&wav_hdr, 1, sizeof(wav_hdr), wav_file);
+	fclose (wav_file);
+}
diff --git a/src/fake86/audio.h b/src/fake86/audio.h
new file mode 100755
index 0000000..112d00c
--- /dev/null
+++ b/src/fake86/audio.h
@@ -0,0 +1,36 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include <stdint.h>
+
+struct wav_hdr_s {
+	uint8_t	RIFF[4];	/* RIFF Header	  */ //Magic header
+	uint32_t ChunkSize;	  /* RIFF Chunk Size  */
+	uint8_t	WAVE[4];	/* WAVE Header	  */
+	uint8_t	fmt[4];	 /* FMT header	   */
+	uint32_t Subchunk1Size;  /* Size of the fmt chunk				*/
+	uint16_t AudioFormat;	/* Audio format 1=PCM,6=mulaw,7=alaw, 257=IBM Mu-Law, 258=IBM A-Law, 259=ADPCM */
+	uint16_t NumOfChan;	  /* Number of channels 1=Mono 2=Sterio		   */
+	uint32_t SamplesPerSec;  /* Sampling Frequency in Hz				 */
+	uint32_t bytesPerSec;	/* bytes per second */
+	uint16_t blockAlign;	 /* 2=16-bit mono, 4=16-bit stereo */
+	uint16_t bitsPerSample;  /* Number of bits per sample	  */
+	uint8_t	Subchunk2ID[4]; /* "data"  string   */
+	uint32_t Subchunk2Size;  /* Sampled data length	*/
+};
diff --git a/src/fake86/blaster.c b/src/fake86/blaster.c
new file mode 100755
index 0000000..33c95c6
--- /dev/null
+++ b/src/fake86/blaster.c
@@ -0,0 +1,316 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* blaster.c: functions to emulate a Creative Labs Sound Blaster Pro. */
+
+#include "config.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include "blaster.h"
+
+extern void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void doirq (uint8_t irqnum);
+extern uint8_t read8237 (uint8_t channel);
+
+extern void outadlib (uint16_t portnum, uint8_t value); //on the Sound Blaster Pro, ports (base+0) and (base+1) are for
+extern uint8_t inadlib (uint16_t portnum); //the OPL FM music chips, and are also mirrored at (base+8) (base+9)
+//as well as 0x388 and 0x389 to remain compatible with the older adlib cards
+
+struct blaster_s blaster;
+
+void bufNewData (uint8_t value) {
+	if (blaster.memptr >= sizeof (blaster.mem) ) return;
+	blaster.mem[blaster.memptr] = value;
+	blaster.memptr++;
+}
+
+extern uint64_t hostfreq;
+void setsampleticks() {
+	if (blaster.samplerate == 0) {
+			blaster.sampleticks = 0;
+			return;
+		}
+	blaster.sampleticks = hostfreq / (uint64_t) blaster.samplerate;
+}
+
+void cmdBlaster (uint8_t value) {
+	uint8_t recognized = 1;
+	if (blaster.waitforarg) {
+			switch (blaster.lastcmdval) {
+					case 0x10: //direct 8-bit sample output
+						blaster.sample = value;
+						break;
+					case 0x14: //8-bit single block DMA output
+					case 0x24:
+					case 0x91:
+						if (blaster.waitforarg == 2) {
+								blaster.blocksize = (blaster.blocksize & 0xFF00) | (uint32_t) value;
+								blaster.waitforarg = 3;
+								return;
+							}
+						else {
+								blaster.blocksize = (blaster.blocksize & 0x00FF) | ( (uint32_t) value << 8);
+#ifdef DEBUG_BLASTER
+								printf ("[NOTICE] Sound Blaster DSP block transfer size set to %u\n", blaster.blocksize);
+#endif
+								blaster.usingdma = 1;
+								blaster.blockstep = 0;
+								blaster.useautoinit = 0;
+								blaster.paused8 = 0;
+								blaster.speakerstate = 1;
+							}
+						break;
+					case 0x40: //set time constant
+						blaster.samplerate = (uint16_t) ( (uint32_t) 1000000 / (uint32_t) (256 - (uint32_t) value) );
+						setsampleticks();
+#ifdef DEBUG_BLASTER
+						printf ("[DEBUG] Sound Blaster time constant received, sample rate = %u\n", blaster.samplerate);
+#endif
+						break;
+					case 0x48: //set DSP block transfer size
+						if (blaster.waitforarg == 2) {
+								blaster.blocksize = (blaster.blocksize & 0xFF00) | (uint32_t) value;
+								blaster.waitforarg = 3;
+								return;
+							}
+						else {
+								blaster.blocksize = (blaster.blocksize & 0x00FF) | ( (uint32_t) value << 8);
+								//if (blaster.blocksize == 0) blaster.blocksize = 65536;
+								blaster.blockstep = 0;
+#ifdef DEBUG_BLASTER
+								printf ("[NOTICE] Sound Blaster DSP block transfer size set to %u\n", blaster.blocksize);
+#endif
+							}
+						break;
+					case 0xE0: //DSP identification for Sound Blaster 2.0 and newer (invert each bit and put in read buffer)
+						bufNewData (~value);
+						break;
+					case 0xE4: //DSP write test, put data value into read buffer
+						bufNewData (value);
+						blaster.lasttestval = value;
+						break;
+					default:
+						recognized = 0;
+				}
+			//blaster.waitforarg--; // = 0;
+			if (recognized) return;
+		}
+
+	switch (value) {
+			case 0x10:
+			case 0x40:
+			case 0xE0:
+			case 0xE4:
+				blaster.waitforarg = 1;
+				break;
+
+			case 0x14: //8-bit single block DMA output
+			case 0x24:
+			case 0x48:
+			case 0x91:
+				blaster.waitforarg = 2;
+				break;
+
+			case 0x1C: //8-bit auto-init DMA output
+			case 0x2C:
+				blaster.usingdma = 1;
+				blaster.blockstep = 0;
+				blaster.useautoinit = 1;
+				blaster.paused8 = 0;
+				blaster.speakerstate = 1;
+				break;
+
+			case 0xD0: //pause 8-bit DMA I/O
+				blaster.paused8 = 1;
+			case 0xD1: //speaker output on
+				blaster.speakerstate = 1;
+				break;
+			case 0xD3: //speaker output off
+				blaster.speakerstate = 0;
+				break;
+			case 0xD4: //continue 8-bit DMA I/O
+				blaster.paused8 = 0;
+				break;
+			case 0xD8: //get speaker status
+				if (blaster.speakerstate) bufNewData (0xFF);
+				else bufNewData (0x00);
+				break;
+			case 0xDA: //exit 8-bit auto-init DMA I/O mode
+				blaster.usingdma = 0;
+				break;
+			case 0xE1: //get DSP version info
+				blaster.memptr = 0;
+				bufNewData (blaster.dspmaj);
+				bufNewData (blaster.dspmin);
+				break;
+			case 0xE8: //DSP read test
+				blaster.memptr = 0;
+				bufNewData (blaster.lasttestval);
+				break;
+			case 0xF2: //force 8-bit IRQ
+				doirq (blaster.sbirq);
+				break;
+			case 0xF8: //undocumented command, clears in-buffer and inserts a null byte
+				blaster.memptr = 0;
+				bufNewData (0);
+				break;
+			default:
+				printf ("[NOTICE] Sound Blaster received unhandled command %02Xh\n", value);
+				break;
+		}
+}
+
+uint8_t mixer[256], mixerindex = 0;
+void outBlaster (uint16_t portnum, uint8_t value) {
+#ifdef DEBUG_BLASTER
+	printf ("[DEBUG] outBlaster: port %Xh, value %02X\n", portnum, value);
+#endif
+	portnum &= 0xF;
+	switch (portnum) {
+			case 0x0:
+			case 0x8:
+				outadlib (0x388, value);
+				break;
+			case 0x1:
+			case 0x9:
+				outadlib (0x389, value);
+				break;
+			case 0x4: //mixer address port
+				mixerindex = value;
+				break;
+			case 0x5: //mixer data
+				mixer[mixerindex] = value;
+				break;
+			case 0x6: //reset port
+				if ( (value == 0x00) && (blaster.lastresetval == 0x01) ) {
+						blaster.speakerstate = 0;
+						blaster.sample = 128;
+						blaster.waitforarg = 0;
+						blaster.memptr = 0;
+						blaster.usingdma = 0;
+						blaster.blocksize = 65535;
+						blaster.blockstep = 0;
+						bufNewData (0xAA);
+						memset (mixer, 0xEE, sizeof (mixer) );
+#ifdef DEBUG_BLASTER
+						printf ("[DEBUG] Sound Blaster received reset!\n");
+#endif
+					}
+				blaster.lastresetval = value;
+				break;
+			case 0xC: //write command/data
+				cmdBlaster (value);
+				if (blaster.waitforarg != 3) blaster.lastcmdval = value;
+				break;
+		}
+}
+
+uint8_t inBlaster (uint16_t portnum) {
+	uint8_t ret = 0;
+#ifdef DEBUG_BLASTER
+	static uint16_t lastread = 0;
+#endif
+#ifdef DEBUG_BLASTER
+	//if (lastread != portnum) printf ("[DEBUG] inBlaster: port %Xh, value ", portnum);
+#endif
+	portnum &= 0xF;
+	switch (portnum) {
+			case 0x0:
+			case 0x8:
+				ret = inadlib (0x388);
+				break;
+			case 0x1:
+			case 0x9:
+				ret = inadlib (0x389);
+				break;
+			case 0x5: //mixer data
+				ret = mixer[mixerindex];
+				break;
+			case 0xA: //read data
+				if (blaster.memptr == 0) {
+						ret = 0;
+					}
+				else {
+						ret = blaster.mem[0];
+						memmove (&blaster.mem[0], &blaster.mem[1], sizeof (blaster.mem) - 1);
+						blaster.memptr--;
+					}
+				break;
+			case 0xE: //read-buffer status
+				if (blaster.memptr > 0) ret = 0x80;
+				else ret = 0x00;
+				break;
+			default:
+				ret = 0x00;
+		}
+#ifdef DEBUG_BLASTER
+	//if (lastread != portnum) printf ("%02X\n", ret);
+	//lastread = portnum;
+#endif
+	return (ret);
+}
+
+//FILE *sbout = NULL;
+void tickBlaster() {
+	if (!blaster.usingdma) return;
+	/*if (blaster.paused8) {
+	blaster.sample = 128;
+	return;
+	}*/
+	//printf("tickBlaster();\n");
+	blaster.sample = read8237 (blaster.sbdma);
+	//if (sbout != NULL) fwrite(&blaster.sample, 1, 1, sbout);
+	blaster.blockstep++;
+	if (blaster.blockstep > blaster.blocksize) {
+			doirq (blaster.sbirq);
+#ifdef DEBUG_BLASTER
+			printf ("[NOTICE] Sound Blaster did IRQ\n");
+#endif
+			if (blaster.useautoinit) {
+					blaster.blockstep = 0;
+				}
+			else {
+					blaster.usingdma = 0;
+				}
+		}
+}
+
+int16_t getBlasterSample() {
+	if (blaster.speakerstate == 0) return (0);
+	else return ( (int16_t) blaster.sample - 128);
+}
+
+void mixerReset() {
+	memset (blaster.mixer.reg, 0, sizeof (blaster.mixer.reg) );
+	blaster.mixer.reg[0x22] = blaster.mixer.reg[0x26] = blaster.mixer.reg[0x04] = (4 << 5) | (4 << 1);
+}
+
+void initBlaster (uint16_t baseport, uint8_t irq) {
+	//sbout = fopen("sbout.raw", "wb");
+	memset (&blaster, 0, sizeof (blaster) );
+	blaster.dspmaj = 2; //emulate a Sound Blaster 2.0
+	blaster.dspmin = 0;
+	blaster.sbirq = irq;
+	blaster.sbdma = 1;
+	mixerReset();
+	set_port_write_redirector (baseport, baseport + 0xE, &outBlaster);
+	set_port_read_redirector (baseport, baseport + 0xE, &inBlaster);
+}
diff --git a/src/fake86/blaster.h b/src/fake86/blaster.h
new file mode 100755
index 0000000..647dc1d
--- /dev/null
+++ b/src/fake86/blaster.h
@@ -0,0 +1,48 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include <stdint.h>
+
+struct blaster_s {
+	uint8_t mem[1024];
+	uint16_t memptr;
+	uint16_t samplerate;
+	uint8_t dspmaj;
+	uint8_t dspmin;
+	uint8_t speakerstate;
+	uint8_t lastresetval;
+	uint8_t lastcmdval;
+	uint8_t lasttestval;
+	uint8_t waitforarg;
+	uint8_t paused8;
+	uint8_t paused16;
+	uint8_t sample;
+	uint8_t sbirq;
+	uint8_t sbdma;
+	uint8_t usingdma;
+	uint8_t maskdma;
+	uint8_t useautoinit;
+	uint32_t blocksize;
+	uint32_t blockstep;
+	uint64_t sampleticks;
+	struct mixer_s {
+		uint8_t index;
+		uint8_t reg[256];
+	} mixer;
+};
diff --git a/src/fake86/config.h b/src/fake86/config.h
new file mode 100755
index 0000000..359c1c0
--- /dev/null
+++ b/src/fake86/config.h
@@ -0,0 +1,60 @@
+#ifndef __CONFIG_H__
+#define __CONFIG_H__
+
+#define BUILD_STRING "Fake86 v0.13.9.16"
+
+//be sure to only define ONE of the CPU_* options at any given time, or
+//you will likely get some unexpected/bad results!
+//#define CPU_8086
+//#define CPU_186
+#define CPU_V20
+//#define CPU_286
+
+#if defined(CPU_8086)
+	#define CPU_CLEAR_ZF_ON_MUL
+	#define CPU_ALLOW_POP_CS
+#else
+	#define CPU_ALLOW_ILLEGAL_OP_EXCEPTION
+	#define CPU_LIMIT_SHIFT_COUNT
+#endif
+
+#if defined(CPU_V20)
+	#define CPU_NO_SALC
+#endif
+
+#if defined(CPU_286) || defined(CPU_386)
+	#define CPU_286_STYLE_PUSH_SP
+#else
+	#define CPU_SET_HIGH_FLAGS
+#endif
+
+#define TIMING_INTERVAL 15
+
+//when USE_PREFETCH_QUEUE is defined, Fake86's CPU emulator uses a 6-byte
+//read-ahead cache for opcode fetches just as a real 8086/8088 does.
+//by default, i just leave this disabled because it wastes a very very
+//small amount of CPU power. however, for the sake of more accurate
+//emulation, it can be enabled by uncommenting the line below and recompiling.
+//#define USE_PREFETCH_QUEUE
+
+//#define CPU_ADDR_MODE_CACHE
+
+//when compiled with network support, fake86 needs libpcap/winpcap.
+//if it is disabled, the ethernet card is still emulated, but no actual
+//communication is possible -- as if the ethernet cable was unplugged.
+#define NETWORKING_OLDCARD //planning to support an NE2000 in the future
+
+//when DISK_CONTROLLER_ATA is defined, fake86 will emulate a true IDE/ATA1 controller
+//card. if it is disabled, emulated disk access is handled by directly intercepting
+//calls to interrupt 13h.
+//*WARNING* - the ATA controller is not currently complete. do not use!
+//#define DISK_CONTROLLER_ATA
+
+#define AUDIO_DEFAULT_SAMPLE_RATE 48000
+#define AUDIO_DEFAULT_LATENCY 100
+
+//#define DEBUG_BLASTER
+//#define DEBUG_DMA
+
+//#define BENCHMARK_BIOS
+#endif
diff --git a/src/fake86/console.c b/src/fake86/console.c
new file mode 100755
index 0000000..03edebb
--- /dev/null
+++ b/src/fake86/console.c
@@ -0,0 +1,133 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* console.c: functions for a simple interactive console on stdio. */
+
+#include "config.h"
+#include <SDL/SDL.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include <conio.h>
+#define strcmpi _strcmpi
+#else
+#define strcmpi strcasecmp
+#endif
+
+uint8_t inputline[1024];
+uint16_t inputptr = 0;
+extern uint8_t running;
+
+extern uint8_t insertdisk (uint8_t drivenum, char *filename);
+extern void ejectdisk (uint8_t drivenum);
+
+void waitforcmd (uint8_t *dst, uint16_t maxlen) {
+#ifdef _WIN32
+	uint16_t inputptr;
+	uint8_t cc;
+
+	inputptr = 0;
+	maxlen -= 2;
+	inputline[0] = 0;
+	while (running) {
+			if (_kbhit () ) {
+					cc = (uint8_t) _getch ();
+					switch (cc) {
+							case 0:
+							case 9:
+							case 10:
+								break;
+							case 8: //backspace
+								if (inputptr > 0) {
+										printf ("%c %c", 8, 8);
+										inputline[--inputptr] = 0;
+									}
+								break;
+							case 13: //enter
+								printf ("\n");
+								return;
+							default:
+								if (inputptr < maxlen) {
+										inputline[inputptr++] = cc;
+										inputline[inputptr] = 0;
+										printf ("%c",cc);
+									}
+						}
+				}
+			SDL_Delay(10); //don't waste CPU time while in the polling loop
+		}
+#else
+	gets (dst);
+#endif
+}
+
+void consolehelp () {
+	printf ("\nConsole command summary:\n");
+	printf ("  The console is not very robust yet. There are only a few commands:\n\n");
+	printf ("    change fd0        Mount a new image file on first floppy drive.\n");
+	printf ("                      Entering a blank line just ejects any current image file.\n");
+	printf ("    change fd1        Mount a new image file on first floppy drive.\n");
+	printf ("                      Entering a blank line just ejects any current image file.\n");
+	printf ("    help              This help display.\n");
+	printf ("    quit              Immediately abort emulation and close Fake86.\n");
+}
+
+#ifdef _WIN32
+void runconsole (void *dummy) {
+#else
+void *runconsole (void *dummy) {
+#endif
+	printf ("\nFake86 management console\n");
+	printf ("Type \"help\" for a summary of commands.\n");
+	while (running) {
+			printf ("\n>");
+			waitforcmd (inputline, sizeof(inputline) );
+			if (strcmpi ( (const char *) inputline, "change fd0") == 0) {
+					printf ("Path to new image file: ");
+					waitforcmd (inputline, sizeof(inputline) );
+					if (strlen (inputline) > 0) {
+							insertdisk (0, (char *) inputline);
+						}
+					else {
+							ejectdisk (0);
+							printf ("Floppy image ejected from first drive.\n");
+						}
+				}
+			else if (strcmpi ( (const char *) inputline, "change fd1") == 0) {
+					printf ("Path to new image file: ");
+					waitforcmd (inputline, sizeof(inputline) );
+					if (strlen (inputline) > 0) {
+							insertdisk (1, (char *) inputline);
+						}
+					else {
+							ejectdisk (1);
+							printf ("Floppy image ejected from second drive.\n");
+						}
+				}
+			else if (strcmpi ( (const char *) inputline, "help") == 0) {
+					consolehelp ();
+				}
+			else if (strcmpi ( (const char *) inputline, "quit") == 0) {
+					running = 0;
+				}
+			else printf("Invalid command was entered.\n");
+		}
+}
diff --git a/src/fake86/cpu.c b/src/fake86/cpu.c
new file mode 100755
index 0000000..828b4d7
--- /dev/null
+++ b/src/fake86/cpu.c
@@ -0,0 +1,3532 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* cpu.c: functions to emulate the 8086/V20 CPU in software. the heart of Fake86. */
+
+#include "config.h"
+#ifndef CPU_INSTRUCTION_FLOW_CACHE
+
+#include <stdint.h>
+#include <stdio.h>
+#include "cpu.h"
+#include "i8259.h"
+#include "i8253.h"
+#include "modregrm.h"
+
+extern struct i8253_s i8253;
+
+extern struct structpic i8259;
+uint64_t curtimer, lasttimer, timerfreq;
+
+uint8_t byteregtable[8] = { regal, regcl, regdl, regbl, regah, regch, regdh, regbh };
+
+static const uint8_t parity[0x100] = {
+	1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+	0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+	0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+	1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+	0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+	1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+	1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+	0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
+};
+
+uint8_t	RAM[0x100000], readonly[0x100000];
+uint8_t	opcode, segoverride, reptype, bootdrive = 0, hdcount = 0, hltstate = 0;
+uint16_t segregs[4], savecs, saveip, ip, useseg, oldsp;
+uint8_t	tempcf, oldcf, cf, pf, af, zf, sf, tf, ifl, df, of, mode, reg, rm;
+uint16_t oper1, oper2, res16, disp16, temp16, dummy, stacksize, frametemp;
+uint8_t	oper1b, oper2b, res8, disp8, temp8, nestlev, addrbyte;
+uint32_t temp1, temp2, temp3, temp4, temp5, temp32, tempaddr32, ea;
+int32_t	result;
+uint64_t totalexec;
+
+extern uint16_t	VGA_SC[0x100], VGA_CRTC[0x100], VGA_ATTR[0x100], VGA_GC[0x100];
+extern uint8_t updatedscreen;
+union _bytewordregs_ regs;
+
+uint8_t	portram[0x10000];
+uint8_t	running = 0, debugmode, showcsip, verbose, mouseemu, didbootstrap = 0;
+uint8_t	ethif;
+
+extern uint8_t	vidmode;
+extern uint8_t verbose;
+
+extern void vidinterrupt();
+
+extern uint8_t readVGA (uint32_t addr32);
+
+void intcall86 (uint8_t intnum);
+
+#define makeflagsword() \
+	( \
+	2 | (uint16_t) cf | ((uint16_t) pf << 2) | ((uint16_t) af << 4) | ((uint16_t) zf << 6) | ((uint16_t) sf << 7) | \
+	((uint16_t) tf << 8) | ((uint16_t) ifl << 9) | ((uint16_t) df << 10) | ((uint16_t) of << 11) \
+	)
+
+#define decodeflagsword(x) { \
+	temp16 = x; \
+	cf = temp16 & 1; \
+	pf = (temp16 >> 2) & 1; \
+	af = (temp16 >> 4) & 1; \
+	zf = (temp16 >> 6) & 1; \
+	sf = (temp16 >> 7) & 1; \
+	tf = (temp16 >> 8) & 1; \
+	ifl = (temp16 >> 9) & 1; \
+	df = (temp16 >> 10) & 1; \
+	of = (temp16 >> 11) & 1; \
+	}
+
+extern void	writeVGA (uint32_t addr32, uint8_t value);
+extern void	portout (uint16_t portnum, uint8_t value);
+extern void	portout16 (uint16_t portnum, uint16_t value);
+extern uint8_t	portin (uint16_t portnum);
+extern uint16_t portin16 (uint16_t portnum);
+
+void write86 (uint32_t addr32, uint8_t value) {
+	tempaddr32 = addr32 & 0xFFFFF;
+#ifdef CPU_ADDR_MODE_CACHE
+	if (!readonly[tempaddr32]) addrcachevalid[tempaddr32] = 0;
+#endif
+	if (readonly[tempaddr32] || (tempaddr32 >= 0xC0000) ) {
+			return;
+		}
+
+	if ( (tempaddr32 >= 0xA0000) && (tempaddr32 <= 0xBFFFF) ) {
+			if ( (vidmode != 0x13) && (vidmode != 0x12) && (vidmode != 0xD) && (vidmode != 0x10) ) {
+					RAM[tempaddr32] = value;
+					updatedscreen = 1;
+				}
+			else if ( ( (VGA_SC[4] & 6) == 0) && (vidmode != 0xD) && (vidmode != 0x10) && (vidmode != 0x12) ) {
+					RAM[tempaddr32] = value;
+					updatedscreen = 1;
+				}
+			else {
+					writeVGA (tempaddr32 - 0xA0000, value);
+				}
+
+			updatedscreen = 1;
+		}
+	else {
+			RAM[tempaddr32] = value;
+		}
+}
+
+void writew86 (uint32_t addr32, uint16_t value) {
+	write86 (addr32, (uint8_t) value);
+	write86 (addr32 + 1, (uint8_t) (value >> 8) );
+}
+
+uint8_t read86 (uint32_t addr32) {
+	addr32 &= 0xFFFFF;
+	if ( (addr32 >= 0xA0000) && (addr32 <= 0xBFFFF) ) {
+			if ( (vidmode == 0xD) || (vidmode == 0xE) || (vidmode == 0x10) || (vidmode == 0x12) ) return (readVGA (addr32 - 0xA0000) );
+			if ( (vidmode != 0x13) && (vidmode != 0x12) && (vidmode != 0xD) ) return (RAM[addr32]);
+			if ( (VGA_SC[4] & 6) == 0)
+				return (RAM[addr32]);
+			else
+				return (readVGA (addr32 - 0xA0000) );
+		}
+
+	if (!didbootstrap) {
+			RAM[0x410] = 0x41; //ugly hack to make BIOS always believe we have an EGA/VGA card installed
+			RAM[0x475] = hdcount; //the BIOS doesn't have any concept of hard drives, so here's another hack
+		}
+
+	return (RAM[addr32]);
+}
+
+uint16_t readw86 (uint32_t addr32) {
+	return ( (uint16_t) read86 (addr32) | (uint16_t) (read86 (addr32 + 1) << 8) );
+}
+
+void flag_szp8 (uint8_t value) {
+	if (!value) {
+			zf = 1;
+		}
+	else {
+			zf = 0;	/* set or clear zero flag */
+		}
+
+	if (value & 0x80) {
+			sf = 1;
+		}
+	else {
+			sf = 0;	/* set or clear sign flag */
+		}
+
+	pf = parity[value]; /* retrieve parity state from lookup table */
+}
+
+void flag_szp16 (uint16_t value) {
+	if (!value) {
+			zf = 1;
+		}
+	else {
+			zf = 0;	/* set or clear zero flag */
+		}
+
+	if (value & 0x8000) {
+			sf = 1;
+		}
+	else {
+			sf = 0;	/* set or clear sign flag */
+		}
+
+	pf = parity[value & 255];	/* retrieve parity state from lookup table */
+}
+
+void flag_log8 (uint8_t value) {
+	flag_szp8 (value);
+	cf = 0;
+	of = 0; /* bitwise logic ops always clear carry and overflow */
+}
+
+void flag_log16 (uint16_t value) {
+	flag_szp16 (value);
+	cf = 0;
+	of = 0; /* bitwise logic ops always clear carry and overflow */
+}
+
+void flag_adc8 (uint8_t v1, uint8_t v2, uint8_t v3) {
+
+	/* v1 = destination operand, v2 = source operand, v3 = carry flag */
+	uint16_t	dst;
+
+	dst = (uint16_t) v1 + (uint16_t) v2 + (uint16_t) v3;
+	flag_szp8 ( (uint8_t) dst);
+	if ( ( (dst ^ v1) & (dst ^ v2) & 0x80) == 0x80) {
+			of = 1;
+		}
+	else {
+			of = 0; /* set or clear overflow flag */
+		}
+
+	if (dst & 0xFF00) {
+			cf = 1;
+		}
+	else {
+			cf = 0; /* set or clear carry flag */
+		}
+
+	if ( ( (v1 ^ v2 ^ dst) & 0x10) == 0x10) {
+			af = 1;
+		}
+	else {
+			af = 0; /* set or clear auxilliary flag */
+		}
+}
+
+void flag_adc16 (uint16_t v1, uint16_t v2, uint16_t v3) {
+
+	uint32_t	dst;
+
+	dst = (uint32_t) v1 + (uint32_t) v2 + (uint32_t) v3;
+	flag_szp16 ( (uint16_t) dst);
+	if ( ( ( (dst ^ v1) & (dst ^ v2) ) & 0x8000) == 0x8000) {
+			of = 1;
+		}
+	else {
+			of = 0;
+		}
+
+	if (dst & 0xFFFF0000) {
+			cf = 1;
+		}
+	else {
+			cf = 0;
+		}
+
+	if ( ( (v1 ^ v2 ^ dst) & 0x10) == 0x10) {
+			af = 1;
+		}
+	else {
+			af = 0;
+		}
+}
+
+void flag_add8 (uint8_t v1, uint8_t v2) {
+	/* v1 = destination operand, v2 = source operand */
+	uint16_t	dst;
+
+	dst = (uint16_t) v1 + (uint16_t) v2;
+	flag_szp8 ( (uint8_t) dst);
+	if (dst & 0xFF00) {
+			cf = 1;
+		}
+	else {
+			cf = 0;
+		}
+
+	if ( ( (dst ^ v1) & (dst ^ v2) & 0x80) == 0x80) {
+			of = 1;
+		}
+	else {
+			of = 0;
+		}
+
+	if ( ( (v1 ^ v2 ^ dst) & 0x10) == 0x10) {
+			af = 1;
+		}
+	else {
+			af = 0;
+		}
+}
+
+void flag_add16 (uint16_t v1, uint16_t v2) {
+	/* v1 = destination operand, v2 = source operand */
+	uint32_t	dst;
+
+	dst = (uint32_t) v1 + (uint32_t) v2;
+	flag_szp16 ( (uint16_t) dst);
+	if (dst & 0xFFFF0000) {
+			cf = 1;
+		}
+	else {
+			cf = 0;
+		}
+
+	if ( ( (dst ^ v1) & (dst ^ v2) & 0x8000) == 0x8000) {
+			of = 1;
+		}
+	else {
+			of = 0;
+		}
+
+	if ( ( (v1 ^ v2 ^ dst) & 0x10) == 0x10) {
+			af = 1;
+		}
+	else {
+			af = 0;
+		}
+}
+
+void flag_sbb8 (uint8_t v1, uint8_t v2, uint8_t v3) {
+
+	/* v1 = destination operand, v2 = source operand, v3 = carry flag */
+	uint16_t	dst;
+
+	v2 += v3;
+	dst = (uint16_t) v1 - (uint16_t) v2;
+	flag_szp8 ( (uint8_t) dst);
+	if (dst & 0xFF00) {
+			cf = 1;
+		}
+	else {
+			cf = 0;
+		}
+
+	if ( (dst ^ v1) & (v1 ^ v2) & 0x80) {
+			of = 1;
+		}
+	else {
+			of = 0;
+		}
+
+	if ( (v1 ^ v2 ^ dst) & 0x10) {
+			af = 1;
+		}
+	else {
+			af = 0;
+		}
+}
+
+void flag_sbb16 (uint16_t v1, uint16_t v2, uint16_t v3) {
+
+	/* v1 = destination operand, v2 = source operand, v3 = carry flag */
+	uint32_t	dst;
+
+	v2 += v3;
+	dst = (uint32_t) v1 - (uint32_t) v2;
+	flag_szp16 ( (uint16_t) dst);
+	if (dst & 0xFFFF0000) {
+			cf = 1;
+		}
+	else {
+			cf = 0;
+		}
+
+	if ( (dst ^ v1) & (v1 ^ v2) & 0x8000) {
+			of = 1;
+		}
+	else {
+			of = 0;
+		}
+
+	if ( (v1 ^ v2 ^ dst) & 0x10) {
+			af = 1;
+		}
+	else {
+			af = 0;
+		}
+}
+
+void flag_sub8 (uint8_t v1, uint8_t v2) {
+
+	/* v1 = destination operand, v2 = source operand */
+	uint16_t	dst;
+
+	dst = (uint16_t) v1 - (uint16_t) v2;
+	flag_szp8 ( (uint8_t) dst);
+	if (dst & 0xFF00) {
+			cf = 1;
+		}
+	else {
+			cf = 0;
+		}
+
+	if ( (dst ^ v1) & (v1 ^ v2) & 0x80) {
+			of = 1;
+		}
+	else {
+			of = 0;
+		}
+
+	if ( (v1 ^ v2 ^ dst) & 0x10) {
+			af = 1;
+		}
+	else {
+			af = 0;
+		}
+}
+
+void flag_sub16 (uint16_t v1, uint16_t v2) {
+
+	/* v1 = destination operand, v2 = source operand */
+	uint32_t	dst;
+
+	dst = (uint32_t) v1 - (uint32_t) v2;
+	flag_szp16 ( (uint16_t) dst);
+	if (dst & 0xFFFF0000) {
+			cf = 1;
+		}
+	else {
+			cf = 0;
+		}
+
+	if ( (dst ^ v1) & (v1 ^ v2) & 0x8000) {
+			of = 1;
+		}
+	else {
+			of = 0;
+		}
+
+	if ( (v1 ^ v2 ^ dst) & 0x10) {
+			af = 1;
+		}
+	else {
+			af = 0;
+		}
+}
+
+void op_adc8() {
+	res8 = oper1b + oper2b + cf;
+	flag_adc8 (oper1b, oper2b, cf);
+}
+
+void op_adc16() {
+	res16 = oper1 + oper2 + cf;
+	flag_adc16 (oper1, oper2, cf);
+}
+
+void op_add8() {
+	res8 = oper1b + oper2b;
+	flag_add8 (oper1b, oper2b);
+}
+
+void op_add16() {
+	res16 = oper1 + oper2;
+	flag_add16 (oper1, oper2);
+}
+
+void op_and8() {
+	res8 = oper1b & oper2b;
+	flag_log8 (res8);
+}
+
+void op_and16() {
+	res16 = oper1 & oper2;
+	flag_log16 (res16);
+}
+
+void op_or8() {
+	res8 = oper1b | oper2b;
+	flag_log8 (res8);
+}
+
+void op_or16() {
+	res16 = oper1 | oper2;
+	flag_log16 (res16);
+}
+
+void op_xor8() {
+	res8 = oper1b ^ oper2b;
+	flag_log8 (res8);
+}
+
+void op_xor16() {
+	res16 = oper1 ^ oper2;
+	flag_log16 (res16);
+}
+
+void op_sub8() {
+	res8 = oper1b - oper2b;
+	flag_sub8 (oper1b, oper2b);
+}
+
+void op_sub16() {
+	res16 = oper1 - oper2;
+	flag_sub16 (oper1, oper2);
+}
+
+void op_sbb8() {
+	res8 = oper1b - (oper2b + cf);
+	flag_sbb8 (oper1b, oper2b, cf);
+}
+
+void op_sbb16() {
+	res16 = oper1 - (oper2 + cf);
+	flag_sbb16 (oper1, oper2, cf);
+}
+
+void getea (uint8_t rmval) {
+	uint32_t	tempea;
+
+	tempea = 0;
+	switch (mode) {
+			case 0:
+				switch (rmval) {
+						case 0:
+							tempea = regs.wordregs[regbx] + regs.wordregs[regsi];
+							break;
+						case 1:
+							tempea = regs.wordregs[regbx] + regs.wordregs[regdi];
+							break;
+						case 2:
+							tempea = regs.wordregs[regbp] + regs.wordregs[regsi];
+							break;
+						case 3:
+							tempea = regs.wordregs[regbp] + regs.wordregs[regdi];
+							break;
+						case 4:
+							tempea = regs.wordregs[regsi];
+							break;
+						case 5:
+							tempea = regs.wordregs[regdi];
+							break;
+						case 6:
+							tempea = disp16;
+							break;
+						case 7:
+							tempea = regs.wordregs[regbx];
+							break;
+					}
+				break;
+
+			case 1:
+			case 2:
+				switch (rmval) {
+						case 0:
+							tempea = regs.wordregs[regbx] + regs.wordregs[regsi] + disp16;
+							break;
+						case 1:
+							tempea = regs.wordregs[regbx] + regs.wordregs[regdi] + disp16;
+							break;
+						case 2:
+							tempea = regs.wordregs[regbp] + regs.wordregs[regsi] + disp16;
+							break;
+						case 3:
+							tempea = regs.wordregs[regbp] + regs.wordregs[regdi] + disp16;
+							break;
+						case 4:
+							tempea = regs.wordregs[regsi] + disp16;
+							break;
+						case 5:
+							tempea = regs.wordregs[regdi] + disp16;
+							break;
+						case 6:
+							tempea = regs.wordregs[regbp] + disp16;
+							break;
+						case 7:
+							tempea = regs.wordregs[regbx] + disp16;
+							break;
+					}
+				break;
+		}
+
+	ea = (tempea & 0xFFFF) + (useseg << 4);
+}
+
+void push (uint16_t pushval) {
+	regs.wordregs[regsp] = regs.wordregs[regsp] - 2;
+	putmem16 (segregs[regss], regs.wordregs[regsp], pushval);
+}
+
+uint16_t pop() {
+
+	uint16_t	tempval;
+
+	tempval = getmem16 (segregs[regss], regs.wordregs[regsp]);
+	regs.wordregs[regsp] = regs.wordregs[regsp] + 2;
+	return tempval;
+}
+
+void reset86() {
+	segregs[regcs] = 0xFFFF;
+	ip = 0x0000;
+	hltstate = 0;
+}
+
+uint16_t readrm16 (uint8_t rmval) {
+	if (mode < 3) {
+			getea (rmval);
+			return read86 (ea) | ( (uint16_t) read86 (ea + 1) << 8);
+		}
+	else {
+			return getreg16 (rmval);
+		}
+}
+
+uint8_t readrm8 (uint8_t rmval) {
+	if (mode < 3) {
+			getea (rmval);
+			return read86 (ea);
+		}
+	else {
+			return getreg8 (rmval);
+		}
+}
+
+void writerm16 (uint8_t rmval, uint16_t value) {
+	if (mode < 3) {
+			getea (rmval);
+			write86 (ea, value & 0xFF);
+			write86 (ea + 1, value >> 8);
+		}
+	else {
+			putreg16 (rmval, value);
+		}
+}
+
+void writerm8 (uint8_t rmval, uint8_t value) {
+	if (mode < 3) {
+			getea (rmval);
+			write86 (ea, value);
+		}
+	else {
+			putreg8 (rmval, value);
+		}
+}
+
+uint8_t op_grp2_8 (uint8_t cnt) {
+
+	uint16_t	s;
+	uint16_t	shift;
+	uint16_t	oldcf;
+	uint16_t	msb;
+
+	s = oper1b;
+	oldcf = cf;
+#ifdef CPU_LIMIT_SHIFT_COUNT
+	cnt &= 0x1F;
+#endif
+	switch (reg) {
+			case 0: /* ROL r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						if (s & 0x80) {
+								cf = 1;
+							}
+						else {
+								cf = 0;
+							}
+
+						s = s << 1;
+						s = s | cf;
+					}
+
+				if (cnt == 1) {
+						//of = cf ^ ( (s >> 7) & 1);
+					if ((s & 0x80) && cf) of = 1; else of = 0;
+					} else of = 0;
+				break;
+
+			case 1: /* ROR r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						cf = s & 1;
+						s = (s >> 1) | (cf << 7);
+					}
+
+				if (cnt == 1) {
+						of = (s >> 7) ^ ( (s >> 6) & 1);
+					}
+				break;
+
+			case 2: /* RCL r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						oldcf = cf;
+						if (s & 0x80) {
+								cf = 1;
+							}
+						else {
+								cf = 0;
+							}
+
+						s = s << 1;
+						s = s | oldcf;
+					}
+
+				if (cnt == 1) {
+						of = cf ^ ( (s >> 7) & 1);
+					}
+				break;
+
+			case 3: /* RCR r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						oldcf = cf;
+						cf = s & 1;
+						s = (s >> 1) | (oldcf << 7);
+					}
+
+				if (cnt == 1) {
+						of = (s >> 7) ^ ( (s >> 6) & 1);
+					}
+				break;
+
+			case 4:
+			case 6: /* SHL r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						if (s & 0x80) {
+								cf = 1;
+							}
+						else {
+								cf = 0;
+							}
+
+						s = (s << 1) & 0xFF;
+					}
+
+				if ( (cnt == 1) && (cf == (s >> 7) ) ) {
+						of = 0;
+					}
+				else {
+						of = 1;
+					}
+
+				flag_szp8 ( (uint8_t) s);
+				break;
+
+			case 5: /* SHR r/m8 */
+				if ( (cnt == 1) && (s & 0x80) ) {
+						of = 1;
+					}
+				else {
+						of = 0;
+					}
+
+				for (shift = 1; shift <= cnt; shift++) {
+						cf = s & 1;
+						s = s >> 1;
+					}
+
+				flag_szp8 ( (uint8_t) s);
+				break;
+
+			case 7: /* SAR r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						msb = s & 0x80;
+						cf = s & 1;
+						s = (s >> 1) | msb;
+					}
+
+				of = 0;
+				flag_szp8 ( (uint8_t) s);
+				break;
+		}
+
+	return s & 0xFF;
+}
+
+uint16_t op_grp2_16 (uint8_t cnt) {
+
+	uint32_t	s;
+	uint32_t	shift;
+	uint32_t	oldcf;
+	uint32_t	msb;
+
+	s = oper1;
+	oldcf = cf;
+#ifdef CPU_LIMIT_SHIFT_COUNT
+	cnt &= 0x1F;
+#endif
+	switch (reg) {
+			case 0: /* ROL r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						if (s & 0x8000) {
+								cf = 1;
+							}
+						else {
+								cf = 0;
+							}
+
+						s = s << 1;
+						s = s | cf;
+					}
+
+				if (cnt == 1) {
+						of = cf ^ ( (s >> 15) & 1);
+					}
+				break;
+
+			case 1: /* ROR r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						cf = s & 1;
+						s = (s >> 1) | (cf << 15);
+					}
+
+				if (cnt == 1) {
+						of = (s >> 15) ^ ( (s >> 14) & 1);
+					}
+				break;
+
+			case 2: /* RCL r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						oldcf = cf;
+						if (s & 0x8000) {
+								cf = 1;
+							}
+						else {
+								cf = 0;
+							}
+
+						s = s << 1;
+						s = s | oldcf;
+					}
+
+				if (cnt == 1) {
+						of = cf ^ ( (s >> 15) & 1);
+					}
+				break;
+
+			case 3: /* RCR r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						oldcf = cf;
+						cf = s & 1;
+						s = (s >> 1) | (oldcf << 15);
+					}
+
+				if (cnt == 1) {
+						of = (s >> 15) ^ ( (s >> 14) & 1);
+					}
+				break;
+
+			case 4:
+			case 6: /* SHL r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						if (s & 0x8000) {
+								cf = 1;
+							}
+						else {
+								cf = 0;
+							}
+
+						s = (s << 1) & 0xFFFF;
+					}
+
+				if ( (cnt == 1) && (cf == (s >> 15) ) ) {
+						of = 0;
+					}
+				else {
+						of = 1;
+					}
+
+				flag_szp16 ( (uint16_t) s);
+				break;
+
+			case 5: /* SHR r/m8 */
+				if ( (cnt == 1) && (s & 0x8000) ) {
+						of = 1;
+					}
+				else {
+						of = 0;
+					}
+
+				for (shift = 1; shift <= cnt; shift++) {
+						cf = s & 1;
+						s = s >> 1;
+					}
+
+				flag_szp16 ( (uint16_t) s);
+				break;
+
+			case 7: /* SAR r/m8 */
+				for (shift = 1; shift <= cnt; shift++) {
+						msb = s & 0x8000;
+						cf = s & 1;
+						s = (s >> 1) | msb;
+					}
+
+				of = 0;
+				flag_szp16 ( (uint16_t) s);
+				break;
+		}
+
+	return (uint16_t) s & 0xFFFF;
+}
+
+void op_div8 (uint16_t valdiv, uint8_t divisor) {
+	if (divisor == 0) {
+			intcall86 (0);
+			return;
+		}
+
+	if ( (valdiv / (uint16_t) divisor) > 0xFF) {
+			intcall86 (0);
+			return;
+		}
+
+	regs.byteregs[regah] = valdiv % (uint16_t) divisor;
+	regs.byteregs[regal] = valdiv / (uint16_t) divisor;
+}
+
+void op_idiv8 (uint16_t valdiv, uint8_t divisor) {
+
+	uint16_t	s1;
+	uint16_t	s2;
+	uint16_t	d1;
+	uint16_t	d2;
+	int	sign;
+
+	if (divisor == 0) {
+			intcall86 (0);
+			return;
+		}
+
+	s1 = valdiv;
+	s2 = divisor;
+	sign = ( ( (s1 ^ s2) & 0x8000) != 0);
+	s1 = (s1 < 0x8000) ? s1 : ( (~s1 + 1) & 0xffff);
+	s2 = (s2 < 0x8000) ? s2 : ( (~s2 + 1) & 0xffff);
+	d1 = s1 / s2;
+	d2 = s1 % s2;
+	if (d1 & 0xFF00) {
+			intcall86 (0);
+			return;
+		}
+
+	if (sign) {
+			d1 = (~d1 + 1) & 0xff;
+			d2 = (~d2 + 1) & 0xff;
+		}
+
+	regs.byteregs[regah] = (uint8_t) d2;
+	regs.byteregs[regal] = (uint8_t) d1;
+}
+
+void op_grp3_8() {
+	oper1 = signext (oper1b);
+	oper2 = signext (oper2b);
+	switch (reg) {
+			case 0:
+			case 1: /* TEST */
+				flag_log8 (oper1b & getmem8 (segregs[regcs], ip) );
+				StepIP (1);
+				break;
+
+			case 2: /* NOT */
+				res8 = ~oper1b;
+				break;
+
+			case 3: /* NEG */
+				res8 = (~oper1b) + 1;
+				flag_sub8 (0, oper1b);
+				if (res8 == 0) {
+						cf = 0;
+					}
+				else {
+						cf = 1;
+					}
+				break;
+
+			case 4: /* MUL */
+				temp1 = (uint32_t) oper1b * (uint32_t) regs.byteregs[regal];
+				regs.wordregs[regax] = temp1 & 0xFFFF;
+				flag_szp8 ( (uint8_t) temp1);
+				if (regs.byteregs[regah]) {
+						cf = 1;
+						of = 1;
+					}
+				else {
+						cf = 0;
+						of = 0;
+					}
+#ifdef CPU_CLEAR_ZF_ON_MUL
+				zf = 0;
+#endif
+				break;
+
+			case 5: /* IMUL */
+				oper1 = signext (oper1b);
+				temp1 = signext (regs.byteregs[regal]);
+				temp2 = oper1;
+				if ( (temp1 & 0x80) == 0x80) {
+						temp1 = temp1 | 0xFFFFFF00;
+					}
+
+				if ( (temp2 & 0x80) == 0x80) {
+						temp2 = temp2 | 0xFFFFFF00;
+					}
+
+				temp3 = (temp1 * temp2) & 0xFFFF;
+				regs.wordregs[regax] = temp3 & 0xFFFF;
+				if (regs.byteregs[regah]) {
+						cf = 1;
+						of = 1;
+					}
+				else {
+						cf = 0;
+						of = 0;
+					}
+#ifdef CPU_CLEAR_ZF_ON_MUL
+				zf = 0;
+#endif
+				break;
+
+			case 6: /* DIV */
+				op_div8 (regs.wordregs[regax], oper1b);
+				break;
+
+			case 7: /* IDIV */
+				op_idiv8 (regs.wordregs[regax], oper1b);
+				break;
+		}
+}
+
+void op_div16 (uint32_t valdiv, uint16_t divisor) {
+	if (divisor == 0) {
+			intcall86 (0);
+			return;
+		}
+
+	if ( (valdiv / (uint32_t) divisor) > 0xFFFF) {
+			intcall86 (0);
+			return;
+		}
+
+	regs.wordregs[regdx] = valdiv % (uint32_t) divisor;
+	regs.wordregs[regax] = valdiv / (uint32_t) divisor;
+}
+
+void op_idiv16 (uint32_t valdiv, uint16_t divisor) {
+
+	uint32_t	d1;
+	uint32_t	d2;
+	uint32_t	s1;
+	uint32_t	s2;
+	int	sign;
+
+	if (divisor == 0) {
+			intcall86 (0);
+			return;
+		}
+
+	s1 = valdiv;
+	s2 = divisor;
+	s2 = (s2 & 0x8000) ? (s2 | 0xffff0000) : s2;
+	sign = ( ( (s1 ^ s2) & 0x80000000) != 0);
+	s1 = (s1 < 0x80000000) ? s1 : ( (~s1 + 1) & 0xffffffff);
+	s2 = (s2 < 0x80000000) ? s2 : ( (~s2 + 1) & 0xffffffff);
+	d1 = s1 / s2;
+	d2 = s1 % s2;
+	if (d1 & 0xFFFF0000) {
+			intcall86 (0);
+			return;
+		}
+
+	if (sign) {
+			d1 = (~d1 + 1) & 0xffff;
+			d2 = (~d2 + 1) & 0xffff;
+		}
+
+	regs.wordregs[regax] = d1;
+	regs.wordregs[regdx] = d2;
+}
+
+void op_grp3_16() {
+	switch (reg) {
+			case 0:
+			case 1: /* TEST */
+				flag_log16 (oper1 & getmem16 (segregs[regcs], ip) );
+				StepIP (2);
+				break;
+
+			case 2: /* NOT */
+				res16 = ~oper1;
+				break;
+
+			case 3: /* NEG */
+				res16 = (~oper1) + 1;
+				flag_sub16 (0, oper1);
+				if (res16) {
+						cf = 1;
+					}
+				else {
+						cf = 0;
+					}
+				break;
+
+			case 4: /* MUL */
+				temp1 = (uint32_t) oper1 * (uint32_t) regs.wordregs[regax];
+				regs.wordregs[regax] = temp1 & 0xFFFF;
+				regs.wordregs[regdx] = temp1 >> 16;
+				flag_szp16 ( (uint16_t) temp1);
+				if (regs.wordregs[regdx]) {
+						cf = 1;
+						of = 1;
+					}
+				else {
+						cf = 0;
+						of = 0;
+					}
+#ifdef CPU_CLEAR_ZF_ON_MUL
+				zf = 0;
+#endif
+				break;
+
+			case 5: /* IMUL */
+				temp1 = regs.wordregs[regax];
+				temp2 = oper1;
+				if (temp1 & 0x8000) {
+						temp1 |= 0xFFFF0000;
+					}
+
+				if (temp2 & 0x8000) {
+						temp2 |= 0xFFFF0000;
+					}
+
+				temp3 = temp1 * temp2;
+				regs.wordregs[regax] = temp3 & 0xFFFF;	/* into register ax */
+				regs.wordregs[regdx] = temp3 >> 16;	/* into register dx */
+				if (regs.wordregs[regdx]) {
+						cf = 1;
+						of = 1;
+					}
+				else {
+						cf = 0;
+						of = 0;
+					}
+#ifdef CPU_CLEAR_ZF_ON_MUL
+				zf = 0;
+#endif
+				break;
+
+			case 6: /* DIV */
+				op_div16 ( ( (uint32_t) regs.wordregs[regdx] << 16) + regs.wordregs[regax], oper1);
+				break;
+
+			case 7: /* DIV */
+				op_idiv16 ( ( (uint32_t) regs.wordregs[regdx] << 16) + regs.wordregs[regax], oper1);
+				break;
+		}
+}
+
+void op_grp5() {
+	switch (reg) {
+			case 0: /* INC Ev */
+				oper2 = 1;
+				tempcf = cf;
+				op_add16();
+				cf = tempcf;
+				writerm16 (rm, res16);
+				break;
+
+			case 1: /* DEC Ev */
+				oper2 = 1;
+				tempcf = cf;
+				op_sub16();
+				cf = tempcf;
+				writerm16 (rm, res16);
+				break;
+
+			case 2: /* CALL Ev */
+				push (ip);
+				ip = oper1;
+				break;
+
+			case 3: /* CALL Mp */
+				push (segregs[regcs]);
+				push (ip);
+				getea (rm);
+				ip = (uint16_t) read86 (ea) + (uint16_t) read86 (ea + 1) * 256;
+				segregs[regcs] = (uint16_t) read86 (ea + 2) + (uint16_t) read86 (ea + 3) * 256;
+				break;
+
+			case 4: /* JMP Ev */
+				ip = oper1;
+				break;
+
+			case 5: /* JMP Mp */
+				getea (rm);
+				ip = (uint16_t) read86 (ea) + (uint16_t) read86 (ea + 1) * 256;
+				segregs[regcs] = (uint16_t) read86 (ea + 2) + (uint16_t) read86 (ea + 3) * 256;
+				break;
+
+			case 6: /* PUSH Ev */
+				push (oper1);
+				break;
+		}
+}
+
+uint8_t dolog = 0, didintr = 0;
+FILE	*logout;
+uint8_t printops = 0;
+
+#ifdef NETWORKING_ENABLED
+extern void nethandler();
+#endif
+extern void diskhandler();
+extern void readdisk (uint8_t drivenum, uint16_t dstseg, uint16_t dstoff, uint16_t cyl, uint16_t sect, uint16_t head, uint16_t sectcount);
+
+void intcall86 (uint8_t intnum) {
+	static uint16_t lastint10ax;
+	uint16_t oldregax;
+	didintr = 1;
+
+	if (intnum == 0x19) didbootstrap = 1;
+
+	switch (intnum) {
+			case 0x10:
+				updatedscreen = 1;
+				/*if (regs.byteregs[regah]!=0x0E) {
+					printf("Int 10h AX = %04X\n", regs.wordregs[regax]);
+				}*/
+				if ( (regs.byteregs[regah]==0x00) || (regs.byteregs[regah]==0x10) ) {
+						oldregax = regs.wordregs[regax];
+						vidinterrupt();
+						regs.wordregs[regax] = oldregax;
+						if (regs.byteregs[regah]==0x10) return;
+						if (vidmode==9) return;
+					}
+				if ( (regs.byteregs[regah]==0x1A) && (lastint10ax!=0x0100) ) { //the 0x0100 is a cheap hack to make it not do this if DOS EDIT/QBASIC
+						regs.byteregs[regal] = 0x1A;
+						regs.byteregs[regbl] = 0x8;
+						return;
+					}
+				lastint10ax = regs.wordregs[regax];
+				if (regs.byteregs[regah]==0x1B) {
+						regs.byteregs[regal] = 0x1B;
+						segregs[reges] = 0xC800;
+						regs.wordregs[regdi] = 0x0000;
+						writew86(0xC8000, 0x0000);
+						writew86(0xC8002, 0xC900);
+						write86(0xC9000, 0x00);
+						write86(0xC9001, 0x00);
+						write86(0xC9002, 0x01);
+						return;
+					}
+				break;
+
+#ifndef DISK_CONTROLLER_ATA
+			case 0x19: //bootstrap
+#ifdef BENCHMARK_BIOS
+				running = 0;
+#endif
+				if (bootdrive<255) { //read first sector of boot drive into 07C0:0000 and execute it
+						regs.byteregs[regdl] = bootdrive;
+						readdisk (regs.byteregs[regdl], 0x07C0, 0x0000, 0, 1, 0, 1);
+						segregs[regcs] = 0x0000;
+						ip = 0x7C00;
+					}
+				else {
+						segregs[regcs] = 0xF600;	//start ROM BASIC at bootstrap if requested
+						ip = 0x0000;
+					}
+				return;
+
+			case 0x13:
+			case 0xFD:
+				diskhandler();
+				return;
+#endif
+#ifdef NETWORKING_OLDCARD
+			case 0xFC:
+#ifdef NETWORKING_ENABLED
+				nethandler();
+#endif
+				return;
+#endif
+		}
+
+	push (makeflagsword() );
+	push (segregs[regcs]);
+	push (ip);
+	segregs[regcs] = getmem16 (0, (uint16_t) intnum * 4 + 2);
+	ip = getmem16 (0, (uint16_t) intnum * 4);
+	ifl = 0;
+	tf = 0;
+}
+
+#if defined(NETWORKING_ENABLED)
+extern struct netstruct {
+	uint8_t	enabled;
+	uint8_t	canrecv;
+	uint16_t	pktlen;
+} net;
+#endif
+uint64_t	frametimer = 0, didwhen = 0, didticks = 0;
+uint32_t	makeupticks = 0;
+extern float	timercomp;
+uint64_t	timerticks = 0, realticks = 0;
+uint64_t	lastcountertimer = 0, counterticks = 10000;
+extern uint8_t	nextintr();
+extern void	timing();
+
+#ifdef USE_PREFETCH_QUEUE
+uint8_t prefetch[6];
+uint32_t prefetch_base = 0;
+#endif
+
+void exec86 (uint32_t execloops) {
+
+	uint32_t loopcount;
+	uint8_t docontinue;
+	static uint16_t firstip;
+	static uint16_t trap_toggle = 0;
+
+	counterticks = (uint64_t) ( (double) timerfreq / (double) 65536.0);
+
+	for (loopcount = 0; loopcount < execloops; loopcount++) {
+
+			if ( (totalexec & TIMING_INTERVAL) == 0) timing();
+
+			if (trap_toggle) {
+					intcall86 (1);
+				}
+
+			if (tf) {
+					trap_toggle = 1;
+				}
+			else {
+					trap_toggle = 0;
+				}
+
+			if (!trap_toggle && (ifl && (i8259.irr & (~i8259.imr) ) ) ) {
+					hltstate = 0;
+					intcall86 (nextintr() );	/* get next interrupt from the i8259, if any */
+				}
+
+			if (hltstate) goto skipexecution;
+
+			/*if ((((uint32_t)segregs[regcs] << 4) + (uint32_t)ip) == 0xFEC59) {
+					//printf("Entered F000:EC59, returning to ");
+					ip = pop();
+					segregs[regcs] = pop();
+					decodeflagsword(pop());
+					//printf("%04X:%04X\n", segregs[regcs], ip);
+					diskhandler();
+				}*/
+
+			reptype = 0;
+			segoverride = 0;
+			useseg = segregs[regds];
+			docontinue = 0;
+			firstip = ip;
+
+			if ( (segregs[regcs] == 0xF000) && (ip == 0xE066) ) didbootstrap = 0; //detect if we hit the BIOS entry point to clear didbootstrap because we've rebooted
+
+			while (!docontinue) {
+					segregs[regcs] = segregs[regcs] & 0xFFFF;
+					ip = ip & 0xFFFF;
+					savecs = segregs[regcs];
+					saveip = ip;
+#ifdef USE_PREFETCH_QUEUE
+					ea = segbase(savecs) + (uint32_t)saveip;
+					if ( (ea < prefetch_base) || (ea > (prefetch_base + 5)) ) {
+							memcpy (&prefetch[0], &RAM[ea], 6);
+							prefetch_base = ea;
+						}
+					opcode = prefetch[ea - prefetch_base];
+#else
+					opcode = getmem8 (segregs[regcs], ip);
+#endif
+					StepIP (1);
+
+					switch (opcode) {
+								/* segment prefix check */
+							case 0x2E:	/* segment segregs[regcs] */
+								useseg = segregs[regcs];
+								segoverride = 1;
+								break;
+
+							case 0x3E:	/* segment segregs[regds] */
+								useseg = segregs[regds];
+								segoverride = 1;
+								break;
+
+							case 0x26:	/* segment segregs[reges] */
+								useseg = segregs[reges];
+								segoverride = 1;
+								break;
+
+							case 0x36:	/* segment segregs[regss] */
+								useseg = segregs[regss];
+								segoverride = 1;
+								break;
+
+								/* repetition prefix check */
+							case 0xF3:	/* REP/REPE/REPZ */
+								reptype = 1;
+								break;
+
+							case 0xF2:	/* REPNE/REPNZ */
+								reptype = 2;
+								break;
+
+							default:
+								docontinue = 1;
+								break;
+						}
+				}
+
+			totalexec++;
+
+			switch (opcode) {
+					case 0x0:	/* 00 ADD Eb Gb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getreg8 (reg);
+						op_add8();
+						writerm8 (rm, res8);
+						break;
+
+					case 0x1:	/* 01 ADD Ev Gv */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getreg16 (reg);
+						op_add16();
+						writerm16 (rm, res16);
+						break;
+
+					case 0x2:	/* 02 ADD Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						op_add8();
+						putreg8 (reg, res8);
+						break;
+
+					case 0x3:	/* 03 ADD Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						op_add16();
+						putreg16 (reg, res16);
+						break;
+
+					case 0x4:	/* 04 ADD regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						op_add8();
+						regs.byteregs[regal] = res8;
+						break;
+
+					case 0x5:	/* 05 ADD eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						op_add16();
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0x6:	/* 06 PUSH segregs[reges] */
+						push (segregs[reges]);
+						break;
+
+					case 0x7:	/* 07 POP segregs[reges] */
+						segregs[reges] = pop();
+						break;
+
+					case 0x8:	/* 08 OR Eb Gb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getreg8 (reg);
+						op_or8();
+						writerm8 (rm, res8);
+						break;
+
+					case 0x9:	/* 09 OR Ev Gv */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getreg16 (reg);
+						op_or16();
+						writerm16 (rm, res16);
+						break;
+
+					case 0xA:	/* 0A OR Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						op_or8();
+						putreg8 (reg, res8);
+						break;
+
+					case 0xB:	/* 0B OR Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						op_or16();
+						if ( (oper1 == 0xF802) && (oper2 == 0xF802) ) {
+								sf = 0;	/* cheap hack to make Wolf 3D think we're a 286 so it plays */
+							}
+
+						putreg16 (reg, res16);
+						break;
+
+					case 0xC:	/* 0C OR regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						op_or8();
+						regs.byteregs[regal] = res8;
+						break;
+
+					case 0xD:	/* 0D OR eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						op_or16();
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0xE:	/* 0E PUSH segregs[regcs] */
+						push (segregs[regcs]);
+						break;
+
+#ifdef CPU_ALLOW_POP_CS //only the 8086/8088 does this.
+					case 0xF: //0F POP CS
+						segregs[regcs] = pop();
+						break;
+#endif
+
+					case 0x10:	/* 10 ADC Eb Gb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getreg8 (reg);
+						op_adc8();
+						writerm8 (rm, res8);
+						break;
+
+					case 0x11:	/* 11 ADC Ev Gv */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getreg16 (reg);
+						op_adc16();
+						writerm16 (rm, res16);
+						break;
+
+					case 0x12:	/* 12 ADC Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						op_adc8();
+						putreg8 (reg, res8);
+						break;
+
+					case 0x13:	/* 13 ADC Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						op_adc16();
+						putreg16 (reg, res16);
+						break;
+
+					case 0x14:	/* 14 ADC regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						op_adc8();
+						regs.byteregs[regal] = res8;
+						break;
+
+					case 0x15:	/* 15 ADC eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						op_adc16();
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0x16:	/* 16 PUSH segregs[regss] */
+						push (segregs[regss]);
+						break;
+
+					case 0x17:	/* 17 POP segregs[regss] */
+						segregs[regss] = pop();
+						break;
+
+					case 0x18:	/* 18 SBB Eb Gb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getreg8 (reg);
+						op_sbb8();
+						writerm8 (rm, res8);
+						break;
+
+					case 0x19:	/* 19 SBB Ev Gv */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getreg16 (reg);
+						op_sbb16();
+						writerm16 (rm, res16);
+						break;
+
+					case 0x1A:	/* 1A SBB Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						op_sbb8();
+						putreg8 (reg, res8);
+						break;
+
+					case 0x1B:	/* 1B SBB Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						op_sbb16();
+						putreg16 (reg, res16);
+						break;
+
+					case 0x1C:	/* 1C SBB regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						op_sbb8();
+						regs.byteregs[regal] = res8;
+						break;
+
+					case 0x1D:	/* 1D SBB eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						op_sbb16();
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0x1E:	/* 1E PUSH segregs[regds] */
+						push (segregs[regds]);
+						break;
+
+					case 0x1F:	/* 1F POP segregs[regds] */
+						segregs[regds] = pop();
+						break;
+
+					case 0x20:	/* 20 AND Eb Gb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getreg8 (reg);
+						op_and8();
+						writerm8 (rm, res8);
+						break;
+
+					case 0x21:	/* 21 AND Ev Gv */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getreg16 (reg);
+						op_and16();
+						writerm16 (rm, res16);
+						break;
+
+					case 0x22:	/* 22 AND Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						op_and8();
+						putreg8 (reg, res8);
+						break;
+
+					case 0x23:	/* 23 AND Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						op_and16();
+						putreg16 (reg, res16);
+						break;
+
+					case 0x24:	/* 24 AND regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						op_and8();
+						regs.byteregs[regal] = res8;
+						break;
+
+					case 0x25:	/* 25 AND eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						op_and16();
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0x27:	/* 27 DAA */
+						if ( ( (regs.byteregs[regal] & 0xF) > 9) || (af == 1) ) {
+								oper1 = regs.byteregs[regal] + 6;
+								regs.byteregs[regal] = oper1 & 255;
+								if (oper1 & 0xFF00) {
+										cf = 1;
+									}
+								else {
+										cf = 0;
+									}
+
+								af = 1;
+							}
+						else {
+								//af = 0;
+							}
+
+						if ( (regs.byteregs[regal]  > 0x9F) || (cf == 1) ) {
+								regs.byteregs[regal] = regs.byteregs[regal] + 0x60;
+								cf = 1;
+							}
+						else {
+								//cf = 0;
+							}
+
+						regs.byteregs[regal] = regs.byteregs[regal] & 255;
+						flag_szp8 (regs.byteregs[regal]);
+						break;
+
+					case 0x28:	/* 28 SUB Eb Gb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getreg8 (reg);
+						op_sub8();
+						writerm8 (rm, res8);
+						break;
+
+					case 0x29:	/* 29 SUB Ev Gv */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getreg16 (reg);
+						op_sub16();
+						writerm16 (rm, res16);
+						break;
+
+					case 0x2A:	/* 2A SUB Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						op_sub8();
+						putreg8 (reg, res8);
+						break;
+
+					case 0x2B:	/* 2B SUB Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						op_sub16();
+						putreg16 (reg, res16);
+						break;
+
+					case 0x2C:	/* 2C SUB regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						op_sub8();
+						regs.byteregs[regal] = res8;
+						break;
+
+					case 0x2D:	/* 2D SUB eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						op_sub16();
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0x2F:	/* 2F DAS */
+						if ( ( (regs.byteregs[regal] & 15) > 9) || (af == 1) ) {
+								oper1 = regs.byteregs[regal] - 6;
+								regs.byteregs[regal] = oper1 & 255;
+								if (oper1 & 0xFF00) {
+										cf = 1;
+									}
+								else {
+										cf = 0;
+									}
+
+								af = 1;
+							}
+						else {
+								af = 0;
+							}
+
+						if ( ( (regs.byteregs[regal] & 0xF0) > 0x90) || (cf == 1) ) {
+								regs.byteregs[regal] = regs.byteregs[regal] - 0x60;
+								cf = 1;
+							}
+						else {
+								cf = 0;
+							}
+
+						flag_szp8 (regs.byteregs[regal]);
+						break;
+
+					case 0x30:	/* 30 XOR Eb Gb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getreg8 (reg);
+						op_xor8();
+						writerm8 (rm, res8);
+						break;
+
+					case 0x31:	/* 31 XOR Ev Gv */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getreg16 (reg);
+						op_xor16();
+						writerm16 (rm, res16);
+						break;
+
+					case 0x32:	/* 32 XOR Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						op_xor8();
+						putreg8 (reg, res8);
+						break;
+
+					case 0x33:	/* 33 XOR Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						op_xor16();
+						putreg16 (reg, res16);
+						break;
+
+					case 0x34:	/* 34 XOR regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						op_xor8();
+						regs.byteregs[regal] = res8;
+						break;
+
+					case 0x35:	/* 35 XOR eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						op_xor16();
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0x37:	/* 37 AAA ASCII */
+						if ( ( (regs.byteregs[regal] & 0xF) > 9) || (af == 1) ) {
+								regs.byteregs[regal] = regs.byteregs[regal] + 6;
+								regs.byteregs[regah] = regs.byteregs[regah] + 1;
+								af = 1;
+								cf = 1;
+							}
+						else {
+								af = 0;
+								cf = 0;
+							}
+
+						regs.byteregs[regal] = regs.byteregs[regal] & 0xF;
+						break;
+
+					case 0x38:	/* 38 CMP Eb Gb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getreg8 (reg);
+						flag_sub8 (oper1b, oper2b);
+						break;
+
+					case 0x39:	/* 39 CMP Ev Gv */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getreg16 (reg);
+						flag_sub16 (oper1, oper2);
+						break;
+
+					case 0x3A:	/* 3A CMP Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						flag_sub8 (oper1b, oper2b);
+						break;
+
+					case 0x3B:	/* 3B CMP Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						flag_sub16 (oper1, oper2);
+						break;
+
+					case 0x3C:	/* 3C CMP regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						flag_sub8 (oper1b, oper2b);
+						break;
+
+					case 0x3D:	/* 3D CMP eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						flag_sub16 (oper1, oper2);
+						break;
+
+					case 0x3F:	/* 3F AAS ASCII */
+						if ( ( (regs.byteregs[regal] & 0xF) > 9) || (af == 1) ) {
+								regs.byteregs[regal] = regs.byteregs[regal] - 6;
+								regs.byteregs[regah] = regs.byteregs[regah] - 1;
+								af = 1;
+								cf = 1;
+							}
+						else {
+								af = 0;
+								cf = 0;
+							}
+
+						regs.byteregs[regal] = regs.byteregs[regal] & 0xF;
+						break;
+
+					case 0x40:	/* 40 INC eAX */
+						oldcf = cf;
+						oper1 = regs.wordregs[regax];
+						oper2 = 1;
+						op_add16();
+						cf = oldcf;
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0x41:	/* 41 INC eCX */
+						oldcf = cf;
+						oper1 = regs.wordregs[regcx];
+						oper2 = 1;
+						op_add16();
+						cf = oldcf;
+						regs.wordregs[regcx] = res16;
+						break;
+
+					case 0x42:	/* 42 INC eDX */
+						oldcf = cf;
+						oper1 = regs.wordregs[regdx];
+						oper2 = 1;
+						op_add16();
+						cf = oldcf;
+						regs.wordregs[regdx] = res16;
+						break;
+
+					case 0x43:	/* 43 INC eBX */
+						oldcf = cf;
+						oper1 = regs.wordregs[regbx];
+						oper2 = 1;
+						op_add16();
+						cf = oldcf;
+						regs.wordregs[regbx] = res16;
+						break;
+
+					case 0x44:	/* 44 INC eSP */
+						oldcf = cf;
+						oper1 = regs.wordregs[regsp];
+						oper2 = 1;
+						op_add16();
+						cf = oldcf;
+						regs.wordregs[regsp] = res16;
+						break;
+
+					case 0x45:	/* 45 INC eBP */
+						oldcf = cf;
+						oper1 = regs.wordregs[regbp];
+						oper2 = 1;
+						op_add16();
+						cf = oldcf;
+						regs.wordregs[regbp] = res16;
+						break;
+
+					case 0x46:	/* 46 INC eSI */
+						oldcf = cf;
+						oper1 = regs.wordregs[regsi];
+						oper2 = 1;
+						op_add16();
+						cf = oldcf;
+						regs.wordregs[regsi] = res16;
+						break;
+
+					case 0x47:	/* 47 INC eDI */
+						oldcf = cf;
+						oper1 = regs.wordregs[regdi];
+						oper2 = 1;
+						op_add16();
+						cf = oldcf;
+						regs.wordregs[regdi] = res16;
+						break;
+
+					case 0x48:	/* 48 DEC eAX */
+						oldcf = cf;
+						oper1 = regs.wordregs[regax];
+						oper2 = 1;
+						op_sub16();
+						cf = oldcf;
+						regs.wordregs[regax] = res16;
+						break;
+
+					case 0x49:	/* 49 DEC eCX */
+						oldcf = cf;
+						oper1 = regs.wordregs[regcx];
+						oper2 = 1;
+						op_sub16();
+						cf = oldcf;
+						regs.wordregs[regcx] = res16;
+						break;
+
+					case 0x4A:	/* 4A DEC eDX */
+						oldcf = cf;
+						oper1 = regs.wordregs[regdx];
+						oper2 = 1;
+						op_sub16();
+						cf = oldcf;
+						regs.wordregs[regdx] = res16;
+						break;
+
+					case 0x4B:	/* 4B DEC eBX */
+						oldcf = cf;
+						oper1 = regs.wordregs[regbx];
+						oper2 = 1;
+						op_sub16();
+						cf = oldcf;
+						regs.wordregs[regbx] = res16;
+						break;
+
+					case 0x4C:	/* 4C DEC eSP */
+						oldcf = cf;
+						oper1 = regs.wordregs[regsp];
+						oper2 = 1;
+						op_sub16();
+						cf = oldcf;
+						regs.wordregs[regsp] = res16;
+						break;
+
+					case 0x4D:	/* 4D DEC eBP */
+						oldcf = cf;
+						oper1 = regs.wordregs[regbp];
+						oper2 = 1;
+						op_sub16();
+						cf = oldcf;
+						regs.wordregs[regbp] = res16;
+						break;
+
+					case 0x4E:	/* 4E DEC eSI */
+						oldcf = cf;
+						oper1 = regs.wordregs[regsi];
+						oper2 = 1;
+						op_sub16();
+						cf = oldcf;
+						regs.wordregs[regsi] = res16;
+						break;
+
+					case 0x4F:	/* 4F DEC eDI */
+						oldcf = cf;
+						oper1 = regs.wordregs[regdi];
+						oper2 = 1;
+						op_sub16();
+						cf = oldcf;
+						regs.wordregs[regdi] = res16;
+						break;
+
+					case 0x50:	/* 50 PUSH eAX */
+						push (regs.wordregs[regax]);
+						break;
+
+					case 0x51:	/* 51 PUSH eCX */
+						push (regs.wordregs[regcx]);
+						break;
+
+					case 0x52:	/* 52 PUSH eDX */
+						push (regs.wordregs[regdx]);
+						break;
+
+					case 0x53:	/* 53 PUSH eBX */
+						push (regs.wordregs[regbx]);
+						break;
+
+					case 0x54:	/* 54 PUSH eSP */
+#ifdef USE_286_STYLE_PUSH_SP
+						push (regs.wordregs[regsp]);
+#else
+						push (regs.wordregs[regsp] - 2);
+#endif
+						break;
+
+					case 0x55:	/* 55 PUSH eBP */
+						push (regs.wordregs[regbp]);
+						break;
+
+					case 0x56:	/* 56 PUSH eSI */
+						push (regs.wordregs[regsi]);
+						break;
+
+					case 0x57:	/* 57 PUSH eDI */
+						push (regs.wordregs[regdi]);
+						break;
+
+					case 0x58:	/* 58 POP eAX */
+						regs.wordregs[regax] = pop();
+						break;
+
+					case 0x59:	/* 59 POP eCX */
+						regs.wordregs[regcx] = pop();
+						break;
+
+					case 0x5A:	/* 5A POP eDX */
+						regs.wordregs[regdx] = pop();
+						break;
+
+					case 0x5B:	/* 5B POP eBX */
+						regs.wordregs[regbx] = pop();
+						break;
+
+					case 0x5C:	/* 5C POP eSP */
+						regs.wordregs[regsp] = pop();
+						break;
+
+					case 0x5D:	/* 5D POP eBP */
+						regs.wordregs[regbp] = pop();
+						break;
+
+					case 0x5E:	/* 5E POP eSI */
+						regs.wordregs[regsi] = pop();
+						break;
+
+					case 0x5F:	/* 5F POP eDI */
+						regs.wordregs[regdi] = pop();
+						break;
+
+#ifndef CPU_8086
+					case 0x60:	/* 60 PUSHA (80186+) */
+						oldsp = regs.wordregs[regsp];
+						push (regs.wordregs[regax]);
+						push (regs.wordregs[regcx]);
+						push (regs.wordregs[regdx]);
+						push (regs.wordregs[regbx]);
+						push (oldsp);
+						push (regs.wordregs[regbp]);
+						push (regs.wordregs[regsi]);
+						push (regs.wordregs[regdi]);
+						break;
+
+					case 0x61:	/* 61 POPA (80186+) */
+						regs.wordregs[regdi] = pop();
+						regs.wordregs[regsi] = pop();
+						regs.wordregs[regbp] = pop();
+						dummy = pop();
+						regs.wordregs[regbx] = pop();
+						regs.wordregs[regdx] = pop();
+						regs.wordregs[regcx] = pop();
+						regs.wordregs[regax] = pop();
+						break;
+
+					case 0x62: /* 62 BOUND Gv, Ev (80186+) */
+						modregrm();
+						getea (rm);
+						if (signext32 (getreg16 (reg) ) < signext32 ( getmem16 (ea >> 4, ea & 15) ) ) {
+								intcall86 (5); //bounds check exception
+							}
+						else {
+								ea += 2;
+								if (signext32 (getreg16 (reg) ) > signext32 ( getmem16 (ea >> 4, ea & 15) ) ) {
+										intcall86(5); //bounds check exception
+									}
+							}
+						break;
+
+					case 0x68:	/* 68 PUSH Iv (80186+) */
+						push (getmem16 (segregs[regcs], ip) );
+						StepIP (2);
+						break;
+
+					case 0x69:	/* 69 IMUL Gv Ev Iv (80186+) */
+						modregrm();
+						temp1 = readrm16 (rm);
+						temp2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						if ( (temp1 & 0x8000L) == 0x8000L) {
+								temp1 = temp1 | 0xFFFF0000L;
+							}
+
+						if ( (temp2 & 0x8000L) == 0x8000L) {
+								temp2 = temp2 | 0xFFFF0000L;
+							}
+
+						temp3 = temp1 * temp2;
+						putreg16 (reg, temp3 & 0xFFFFL);
+						if (temp3 & 0xFFFF0000L) {
+								cf = 1;
+								of = 1;
+							}
+						else {
+								cf = 0;
+								of = 0;
+							}
+						break;
+
+					case 0x6A:	/* 6A PUSH Ib (80186+) */
+						push (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						break;
+
+					case 0x6B:	/* 6B IMUL Gv Eb Ib (80186+) */
+						modregrm();
+						temp1 = readrm16 (rm);
+						temp2 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if ( (temp1 & 0x8000L) == 0x8000L) {
+								temp1 = temp1 | 0xFFFF0000L;
+							}
+
+						if ( (temp2 & 0x8000L) == 0x8000L) {
+								temp2 = temp2 | 0xFFFF0000L;
+							}
+
+						temp3 = temp1 * temp2;
+						putreg16 (reg, temp3 & 0xFFFFL);
+						if (temp3 & 0xFFFF0000L) {
+								cf = 1;
+								of = 1;
+							}
+						else {
+								cf = 0;
+								of = 0;
+							}
+						break;
+
+					case 0x6C:	/* 6E INSB */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						putmem8 (useseg, regs.wordregs[regsi], portin (regs.wordregs[regdx]) );
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 1;
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 1;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 1;
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 1;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0x6D:	/* 6F INSW */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						putmem16 (useseg, regs.wordregs[regsi], portin16 (regs.wordregs[regdx]) );
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 2;
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 2;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 2;
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 2;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0x6E:	/* 6E OUTSB */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						portout (regs.wordregs[regdx], getmem8 (useseg, regs.wordregs[regsi]) );
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 1;
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 1;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 1;
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 1;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0x6F:	/* 6F OUTSW */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						portout16 (regs.wordregs[regdx], getmem16 (useseg, regs.wordregs[regsi]) );
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 2;
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 2;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 2;
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 2;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+#endif
+
+					case 0x70:	/* 70 JO Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (of) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x71:	/* 71 JNO Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (!of) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x72:	/* 72 JB Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (cf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x73:	/* 73 JNB Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (!cf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x74:	/* 74 JZ Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (zf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x75:	/* 75 JNZ Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (!zf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x76:	/* 76 JBE Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (cf || zf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x77:	/* 77 JA Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (!cf && !zf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x78:	/* 78 JS Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (sf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x79:	/* 79 JNS Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (!sf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x7A:	/* 7A JPE Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (pf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x7B:	/* 7B JPO Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (!pf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x7C:	/* 7C JL Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (sf != of) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x7D:	/* 7D JGE Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (sf == of) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x7E:	/* 7E JLE Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if ( (sf != of) || zf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x7F:	/* 7F JG Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (!zf && (sf == of) ) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0x80:
+					case 0x82:	/* 80/82 GRP1 Eb Ib */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						switch (reg) {
+								case 0:
+									op_add8();
+									break;
+								case 1:
+									op_or8();
+									break;
+								case 2:
+									op_adc8();
+									break;
+								case 3:
+									op_sbb8();
+									break;
+								case 4:
+									op_and8();
+									break;
+								case 5:
+									op_sub8();
+									break;
+								case 6:
+									op_xor8();
+									break;
+								case 7:
+									flag_sub8 (oper1b, oper2b);
+									break;
+								default:
+									break;	/* to avoid compiler warnings */
+							}
+
+						if (reg < 7) {
+								writerm8 (rm, res8);
+							}
+						break;
+
+					case 0x81:	/* 81 GRP1 Ev Iv */
+					case 0x83:	/* 83 GRP1 Ev Ib */
+						modregrm();
+						oper1 = readrm16 (rm);
+						if (opcode == 0x81) {
+								oper2 = getmem16 (segregs[regcs], ip);
+								StepIP (2);
+							}
+						else {
+								oper2 = signext (getmem8 (segregs[regcs], ip) );
+								StepIP (1);
+							}
+
+						switch (reg) {
+								case 0:
+									op_add16();
+									break;
+								case 1:
+									op_or16();
+									break;
+								case 2:
+									op_adc16();
+									break;
+								case 3:
+									op_sbb16();
+									break;
+								case 4:
+									op_and16();
+									break;
+								case 5:
+									op_sub16();
+									break;
+								case 6:
+									op_xor16();
+									break;
+								case 7:
+									flag_sub16 (oper1, oper2);
+									break;
+								default:
+									break;	/* to avoid compiler warnings */
+							}
+
+						if (reg < 7) {
+								writerm16 (rm, res16);
+							}
+						break;
+
+					case 0x84:	/* 84 TEST Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						oper2b = readrm8 (rm);
+						flag_log8 (oper1b & oper2b);
+						break;
+
+					case 0x85:	/* 85 TEST Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						oper2 = readrm16 (rm);
+						flag_log16 (oper1 & oper2);
+						break;
+
+					case 0x86:	/* 86 XCHG Gb Eb */
+						modregrm();
+						oper1b = getreg8 (reg);
+						putreg8 (reg, readrm8 (rm) );
+						writerm8 (rm, oper1b);
+						break;
+
+					case 0x87:	/* 87 XCHG Gv Ev */
+						modregrm();
+						oper1 = getreg16 (reg);
+						putreg16 (reg, readrm16 (rm) );
+						writerm16 (rm, oper1);
+						break;
+
+					case 0x88:	/* 88 MOV Eb Gb */
+						modregrm();
+						writerm8 (rm, getreg8 (reg) );
+						break;
+
+					case 0x89:	/* 89 MOV Ev Gv */
+						modregrm();
+						writerm16 (rm, getreg16 (reg) );
+						break;
+
+					case 0x8A:	/* 8A MOV Gb Eb */
+						modregrm();
+						putreg8 (reg, readrm8 (rm) );
+						break;
+
+					case 0x8B:	/* 8B MOV Gv Ev */
+						modregrm();
+						putreg16 (reg, readrm16 (rm) );
+						break;
+
+					case 0x8C:	/* 8C MOV Ew Sw */
+						modregrm();
+						writerm16 (rm, getsegreg (reg) );
+						break;
+
+					case 0x8D:	/* 8D LEA Gv M */
+						modregrm();
+						getea (rm);
+						putreg16 (reg, ea - segbase (useseg) );
+						break;
+
+					case 0x8E:	/* 8E MOV Sw Ew */
+						modregrm();
+						putsegreg (reg, readrm16 (rm) );
+						break;
+
+					case 0x8F:	/* 8F POP Ev */
+						modregrm();
+						writerm16 (rm, pop() );
+						break;
+
+					case 0x90:	/* 90 NOP */
+						break;
+
+					case 0x91:	/* 91 XCHG eCX eAX */
+						oper1 = regs.wordregs[regcx];
+						regs.wordregs[regcx] = regs.wordregs[regax];
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0x92:	/* 92 XCHG eDX eAX */
+						oper1 = regs.wordregs[regdx];
+						regs.wordregs[regdx] = regs.wordregs[regax];
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0x93:	/* 93 XCHG eBX eAX */
+						oper1 = regs.wordregs[regbx];
+						regs.wordregs[regbx] = regs.wordregs[regax];
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0x94:	/* 94 XCHG eSP eAX */
+						oper1 = regs.wordregs[regsp];
+						regs.wordregs[regsp] = regs.wordregs[regax];
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0x95:	/* 95 XCHG eBP eAX */
+						oper1 = regs.wordregs[regbp];
+						regs.wordregs[regbp] = regs.wordregs[regax];
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0x96:	/* 96 XCHG eSI eAX */
+						oper1 = regs.wordregs[regsi];
+						regs.wordregs[regsi] = regs.wordregs[regax];
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0x97:	/* 97 XCHG eDI eAX */
+						oper1 = regs.wordregs[regdi];
+						regs.wordregs[regdi] = regs.wordregs[regax];
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0x98:	/* 98 CBW */
+						if ( (regs.byteregs[regal] & 0x80) == 0x80) {
+								regs.byteregs[regah] = 0xFF;
+							}
+						else {
+								regs.byteregs[regah] = 0;
+							}
+						break;
+
+					case 0x99:	/* 99 CWD */
+						if ( (regs.byteregs[regah] & 0x80) == 0x80) {
+								regs.wordregs[regdx] = 0xFFFF;
+							}
+						else {
+								regs.wordregs[regdx] = 0;
+							}
+						break;
+
+					case 0x9A:	/* 9A CALL Ap */
+						oper1 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						push (segregs[regcs]);
+						push (ip);
+						ip = oper1;
+						segregs[regcs] = oper2;
+						break;
+
+					case 0x9B:	/* 9B WAIT */
+						break;
+
+					case 0x9C:	/* 9C PUSHF */
+#ifdef CPU_SET_HIGH_FLAGS
+						push (makeflagsword() | 0xF800);
+#else
+						push (makeflagsword() | 0x0800);
+#endif
+						break;
+
+					case 0x9D:	/* 9D POPF */
+						temp16 = pop();
+						decodeflagsword (temp16);
+						break;
+
+					case 0x9E:	/* 9E SAHF */
+						decodeflagsword ( (makeflagsword() & 0xFF00) | regs.byteregs[regah]);
+						break;
+
+					case 0x9F:	/* 9F LAHF */
+						regs.byteregs[regah] = makeflagsword() & 0xFF;
+						break;
+
+					case 0xA0:	/* A0 MOV regs.byteregs[regal] Ob */
+						regs.byteregs[regal] = getmem8 (useseg, getmem16 (segregs[regcs], ip) );
+						StepIP (2);
+						break;
+
+					case 0xA1:	/* A1 MOV eAX Ov */
+						oper1 = getmem16 (useseg, getmem16 (segregs[regcs], ip) );
+						StepIP (2);
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0xA2:	/* A2 MOV Ob regs.byteregs[regal] */
+						putmem8 (useseg, getmem16 (segregs[regcs], ip), regs.byteregs[regal]);
+						StepIP (2);
+						break;
+
+					case 0xA3:	/* A3 MOV Ov eAX */
+						putmem16 (useseg, getmem16 (segregs[regcs], ip), regs.wordregs[regax]);
+						StepIP (2);
+						break;
+
+					case 0xA4:	/* A4 MOVSB */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						putmem8 (segregs[reges], regs.wordregs[regdi], getmem8 (useseg, regs.wordregs[regsi]) );
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 1;
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 1;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 1;
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 1;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xA5:	/* A5 MOVSW */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						putmem16 (segregs[reges], regs.wordregs[regdi], getmem16 (useseg, regs.wordregs[regsi]) );
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 2;
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 2;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 2;
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 2;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xA6:	/* A6 CMPSB */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						oper1b = getmem8 (useseg, regs.wordregs[regsi]);
+						oper2b = getmem8 (segregs[reges], regs.wordregs[regdi]);
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 1;
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 1;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 1;
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 1;
+							}
+
+						flag_sub8 (oper1b, oper2b);
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						if ( (reptype == 1) && !zf) {
+								break;
+							}
+						else if ( (reptype == 2) && (zf == 1) ) {
+								break;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xA7:	/* A7 CMPSW */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						oper1 = getmem16 (useseg,regs.wordregs[regsi]);
+						oper2 = getmem16 (segregs[reges], regs.wordregs[regdi]);
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 2;
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 2;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 2;
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 2;
+							}
+
+						flag_sub16 (oper1, oper2);
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						if ( (reptype == 1) && !zf) {
+								break;
+							}
+
+						if ( (reptype == 2) && (zf == 1) ) {
+								break;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xA8:	/* A8 TEST regs.byteregs[regal] Ib */
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						flag_log8 (oper1b & oper2b);
+						break;
+
+					case 0xA9:	/* A9 TEST eAX Iv */
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						flag_log16 (oper1 & oper2);
+						break;
+
+					case 0xAA:	/* AA STOSB */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						putmem8 (segregs[reges], regs.wordregs[regdi], regs.byteregs[regal]);
+						if (df) {
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 1;
+							}
+						else {
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 1;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xAB:	/* AB STOSW */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						putmem16 (segregs[reges], regs.wordregs[regdi], regs.wordregs[regax]);
+						if (df) {
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 2;
+							}
+						else {
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 2;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xAC:	/* AC LODSB */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						regs.byteregs[regal] = getmem8 (useseg, regs.wordregs[regsi]);
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 1;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 1;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xAD:	/* AD LODSW */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						oper1 = getmem16 (useseg, regs.wordregs[regsi]);
+						regs.wordregs[regax] = oper1;
+						if (df) {
+								regs.wordregs[regsi] = regs.wordregs[regsi] - 2;
+							}
+						else {
+								regs.wordregs[regsi] = regs.wordregs[regsi] + 2;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xAE:	/* AE SCASB */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						oper1b = regs.byteregs[regal];
+						oper2b = getmem8 (segregs[reges], regs.wordregs[regdi]);
+						flag_sub8 (oper1b, oper2b);
+						if (df) {
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 1;
+							}
+						else {
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 1;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						if ( (reptype == 1) && !zf) {
+								break;
+							}
+						else if ( (reptype == 2) && (zf == 1) ) {
+								break;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xAF:	/* AF SCASW */
+						if (reptype && (regs.wordregs[regcx] == 0) ) {
+								break;
+							}
+
+						oper1 = regs.wordregs[regax];
+						oper2 = getmem16 (segregs[reges], regs.wordregs[regdi]);
+						flag_sub16 (oper1, oper2);
+						if (df) {
+								regs.wordregs[regdi] = regs.wordregs[regdi] - 2;
+							}
+						else {
+								regs.wordregs[regdi] = regs.wordregs[regdi] + 2;
+							}
+
+						if (reptype) {
+								regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+							}
+
+						if ( (reptype == 1) && !zf) {
+								break;
+							}
+						else if ( (reptype == 2) & (zf == 1) ) {
+								break;
+							}
+
+						totalexec++;
+						loopcount++;
+						if (!reptype) {
+								break;
+							}
+
+						ip = firstip;
+						break;
+
+					case 0xB0:	/* B0 MOV regs.byteregs[regal] Ib */
+						regs.byteregs[regal] = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						break;
+
+					case 0xB1:	/* B1 MOV regs.byteregs[regcl] Ib */
+						regs.byteregs[regcl] = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						break;
+
+					case 0xB2:	/* B2 MOV regs.byteregs[regdl] Ib */
+						regs.byteregs[regdl] = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						break;
+
+					case 0xB3:	/* B3 MOV regs.byteregs[regbl] Ib */
+						regs.byteregs[regbl] = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						break;
+
+					case 0xB4:	/* B4 MOV regs.byteregs[regah] Ib */
+						regs.byteregs[regah] = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						break;
+
+					case 0xB5:	/* B5 MOV regs.byteregs[regch] Ib */
+						regs.byteregs[regch] = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						break;
+
+					case 0xB6:	/* B6 MOV regs.byteregs[regdh] Ib */
+						regs.byteregs[regdh] = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						break;
+
+					case 0xB7:	/* B7 MOV regs.byteregs[regbh] Ib */
+						regs.byteregs[regbh] = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						break;
+
+					case 0xB8:	/* B8 MOV eAX Iv */
+						oper1 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						regs.wordregs[regax] = oper1;
+						break;
+
+					case 0xB9:	/* B9 MOV eCX Iv */
+						oper1 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						regs.wordregs[regcx] = oper1;
+						break;
+
+					case 0xBA:	/* BA MOV eDX Iv */
+						oper1 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						regs.wordregs[regdx] = oper1;
+						break;
+
+					case 0xBB:	/* BB MOV eBX Iv */
+						oper1 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						regs.wordregs[regbx] = oper1;
+						break;
+
+					case 0xBC:	/* BC MOV eSP Iv */
+						regs.wordregs[regsp] = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						break;
+
+					case 0xBD:	/* BD MOV eBP Iv */
+						regs.wordregs[regbp] = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						break;
+
+					case 0xBE:	/* BE MOV eSI Iv */
+						regs.wordregs[regsi] = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						break;
+
+					case 0xBF:	/* BF MOV eDI Iv */
+						regs.wordregs[regdi] = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						break;
+
+					case 0xC0:	/* C0 GRP2 byte imm8 (80186+) */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						writerm8 (rm, op_grp2_8 (oper2b) );
+						break;
+
+					case 0xC1:	/* C1 GRP2 word imm8 (80186+) */
+						modregrm();
+						oper1 = readrm16 (rm);
+						oper2 = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						writerm16 (rm, op_grp2_16 ( (uint8_t) oper2) );
+						break;
+
+					case 0xC2:	/* C2 RET Iw */
+						oper1 = getmem16 (segregs[regcs], ip);
+						ip = pop();
+						regs.wordregs[regsp] = regs.wordregs[regsp] + oper1;
+						break;
+
+					case 0xC3:	/* C3 RET */
+						ip = pop();
+						break;
+
+					case 0xC4:	/* C4 LES Gv Mp */
+						modregrm();
+						getea (rm);
+						putreg16 (reg, read86 (ea) + read86 (ea + 1) * 256);
+						segregs[reges] = read86 (ea + 2) + read86 (ea + 3) * 256;
+						break;
+
+					case 0xC5:	/* C5 LDS Gv Mp */
+						modregrm();
+						getea (rm);
+						putreg16 (reg, read86 (ea) + read86 (ea + 1) * 256);
+						segregs[regds] = read86 (ea + 2) + read86 (ea + 3) * 256;
+						break;
+
+					case 0xC6:	/* C6 MOV Eb Ib */
+						modregrm();
+						writerm8 (rm, getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						break;
+
+					case 0xC7:	/* C7 MOV Ev Iv */
+						modregrm();
+						writerm16 (rm, getmem16 (segregs[regcs], ip) );
+						StepIP (2);
+						break;
+
+					case 0xC8:	/* C8 ENTER (80186+) */
+						stacksize = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						nestlev = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						push (regs.wordregs[regbp]);
+						frametemp = regs.wordregs[regsp];
+						if (nestlev) {
+								for (temp16 = 1; temp16 < nestlev; temp16++) {
+										regs.wordregs[regbp] = regs.wordregs[regbp] - 2;
+										push (regs.wordregs[regbp]);
+									}
+
+								push (regs.wordregs[regsp]);
+							}
+
+						regs.wordregs[regbp] = frametemp;
+						regs.wordregs[regsp] = regs.wordregs[regbp] - stacksize;
+
+						break;
+
+					case 0xC9:	/* C9 LEAVE (80186+) */
+						regs.wordregs[regsp] = regs.wordregs[regbp];
+						regs.wordregs[regbp] = pop();
+						break;
+
+					case 0xCA:	/* CA RETF Iw */
+						oper1 = getmem16 (segregs[regcs], ip);
+						ip = pop();
+						segregs[regcs] = pop();
+						regs.wordregs[regsp] = regs.wordregs[regsp] + oper1;
+						break;
+
+					case 0xCB:	/* CB RETF */
+						ip = pop();;
+						segregs[regcs] = pop();
+						break;
+
+					case 0xCC:	/* CC INT 3 */
+						intcall86 (3);
+						break;
+
+					case 0xCD:	/* CD INT Ib */
+						oper1b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						intcall86 (oper1b);
+						break;
+
+					case 0xCE:	/* CE INTO */
+						if (of) {
+								intcall86 (4);
+							}
+						break;
+
+					case 0xCF:	/* CF IRET */
+						ip = pop();
+						segregs[regcs] = pop();
+						decodeflagsword (pop() );
+
+						/*
+						 * if (net.enabled) net.canrecv = 1;
+						 */
+						break;
+
+					case 0xD0:	/* D0 GRP2 Eb 1 */
+						modregrm();
+						oper1b = readrm8 (rm);
+						writerm8 (rm, op_grp2_8 (1) );
+						break;
+
+					case 0xD1:	/* D1 GRP2 Ev 1 */
+						modregrm();
+						oper1 = readrm16 (rm);
+						writerm16 (rm, op_grp2_16 (1) );
+						break;
+
+					case 0xD2:	/* D2 GRP2 Eb regs.byteregs[regcl] */
+						modregrm();
+						oper1b = readrm8 (rm);
+						writerm8 (rm, op_grp2_8 (regs.byteregs[regcl]) );
+						break;
+
+					case 0xD3:	/* D3 GRP2 Ev regs.byteregs[regcl] */
+						modregrm();
+						oper1 = readrm16 (rm);
+						writerm16 (rm, op_grp2_16 (regs.byteregs[regcl]) );
+						break;
+
+					case 0xD4:	/* D4 AAM I0 */
+						oper1 = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						if (!oper1) {
+								intcall86 (0);
+								break;
+							}	/* division by zero */
+
+						regs.byteregs[regah] = (regs.byteregs[regal] / oper1) & 255;
+						regs.byteregs[regal] = (regs.byteregs[regal] % oper1) & 255;
+						flag_szp16 (regs.wordregs[regax]);
+						break;
+
+					case 0xD5:	/* D5 AAD I0 */
+						oper1 = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						regs.byteregs[regal] = (regs.byteregs[regah] * oper1 + regs.byteregs[regal]) & 255;
+						regs.byteregs[regah] = 0;
+						flag_szp16 (regs.byteregs[regah] * oper1 + regs.byteregs[regal]);
+						sf = 0;
+						break;
+
+					case 0xD6:	/* D6 XLAT on V20/V30, SALC on 8086/8088 */
+#ifndef CPU_NO_SALC
+						regs.byteregs[regal] = cf ? 0xFF : 0x00;
+						break;
+#endif
+
+					case 0xD7:	/* D7 XLAT */
+						regs.byteregs[regal] = read86(useseg * 16 + (regs.wordregs[regbx]) + regs.byteregs[regal]);
+						break;
+
+					case 0xD8:
+					case 0xD9:
+					case 0xDA:
+					case 0xDB:
+					case 0xDC:
+					case 0xDE:
+					case 0xDD:
+					case 0xDF:	/* escape to x87 FPU (unsupported) */
+						modregrm();
+						break;
+
+					case 0xE0:	/* E0 LOOPNZ Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+						if ( (regs.wordregs[regcx]) && !zf) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0xE1:	/* E1 LOOPZ Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+						if (regs.wordregs[regcx] && (zf == 1) ) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0xE2:	/* E2 LOOP Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						regs.wordregs[regcx] = regs.wordregs[regcx] - 1;
+						if (regs.wordregs[regcx]) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0xE3:	/* E3 JCXZ Jb */
+						temp16 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						if (!regs.wordregs[regcx]) {
+								ip = ip + temp16;
+							}
+						break;
+
+					case 0xE4:	/* E4 IN regs.byteregs[regal] Ib */
+						oper1b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						regs.byteregs[regal] = (uint8_t) portin (oper1b);
+						break;
+
+					case 0xE5:	/* E5 IN eAX Ib */
+						oper1b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						regs.wordregs[regax] = portin16 (oper1b);
+						break;
+
+					case 0xE6:	/* E6 OUT Ib regs.byteregs[regal] */
+						oper1b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						portout (oper1b, regs.byteregs[regal]);
+						break;
+
+					case 0xE7:	/* E7 OUT Ib eAX */
+						oper1b = getmem8 (segregs[regcs], ip);
+						StepIP (1);
+						portout16 (oper1b, regs.wordregs[regax]);
+						break;
+
+					case 0xE8:	/* E8 CALL Jv */
+						oper1 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						push (ip);
+						ip = ip + oper1;
+						break;
+
+					case 0xE9:	/* E9 JMP Jv */
+						oper1 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						ip = ip + oper1;
+						break;
+
+					case 0xEA:	/* EA JMP Ap */
+						oper1 = getmem16 (segregs[regcs], ip);
+						StepIP (2);
+						oper2 = getmem16 (segregs[regcs], ip);
+						ip = oper1;
+						segregs[regcs] = oper2;
+						break;
+
+					case 0xEB:	/* EB JMP Jb */
+						oper1 = signext (getmem8 (segregs[regcs], ip) );
+						StepIP (1);
+						ip = ip + oper1;
+						break;
+
+					case 0xEC:	/* EC IN regs.byteregs[regal] regdx */
+						oper1 = regs.wordregs[regdx];
+						regs.byteregs[regal] = (uint8_t) portin (oper1);
+						break;
+
+					case 0xED:	/* ED IN eAX regdx */
+						oper1 = regs.wordregs[regdx];
+						regs.wordregs[regax] = portin16 (oper1);
+						break;
+
+					case 0xEE:	/* EE OUT regdx regs.byteregs[regal] */
+						oper1 = regs.wordregs[regdx];
+						portout (oper1, regs.byteregs[regal]);
+						break;
+
+					case 0xEF:	/* EF OUT regdx eAX */
+						oper1 = regs.wordregs[regdx];
+						portout16 (oper1, regs.wordregs[regax]);
+						break;
+
+					case 0xF0:	/* F0 LOCK */
+						break;
+
+					case 0xF4:	/* F4 HLT */
+						hltstate = 1;
+						break;
+
+					case 0xF5:	/* F5 CMC */
+						if (!cf) {
+								cf = 1;
+							}
+						else {
+								cf = 0;
+							}
+						break;
+
+					case 0xF6:	/* F6 GRP3a Eb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						op_grp3_8();
+						if ( (reg > 1) && (reg < 4) ) {
+								writerm8 (rm, res8);
+							}
+						break;
+
+					case 0xF7:	/* F7 GRP3b Ev */
+						modregrm();
+						oper1 = readrm16 (rm);
+						op_grp3_16();
+						if ( (reg > 1) && (reg < 4) ) {
+								writerm16 (rm, res16);
+							}
+						break;
+
+					case 0xF8:	/* F8 CLC */
+						cf = 0;
+						break;
+
+					case 0xF9:	/* F9 STC */
+						cf = 1;
+						break;
+
+					case 0xFA:	/* FA CLI */
+						ifl = 0;
+						break;
+
+					case 0xFB:	/* FB STI */
+						ifl = 1;
+						break;
+
+					case 0xFC:	/* FC CLD */
+						df = 0;
+						break;
+
+					case 0xFD:	/* FD STD */
+						df = 1;
+						break;
+
+					case 0xFE:	/* FE GRP4 Eb */
+						modregrm();
+						oper1b = readrm8 (rm);
+						oper2b = 1;
+						if (!reg) {
+								tempcf = cf;
+								res8 = oper1b + oper2b;
+								flag_add8 (oper1b, oper2b);
+								cf = tempcf;
+								writerm8 (rm, res8);
+							}
+						else {
+								tempcf = cf;
+								res8 = oper1b - oper2b;
+								flag_sub8 (oper1b, oper2b);
+								cf = tempcf;
+								writerm8 (rm, res8);
+							}
+						break;
+
+					case 0xFF:	/* FF GRP5 Ev */
+						modregrm();
+						oper1 = readrm16 (rm);
+						op_grp5();
+						break;
+
+					default:
+#ifdef CPU_ALLOW_ILLEGAL_OP_EXCEPTION
+						intcall86 (6); /* trip invalid opcode exception (this occurs on the 80186+, 8086/8088 CPUs treat them as NOPs. */
+						               /* technically they aren't exactly like NOPs in most cases, but for our pursoses, that's accurate enough. */
+#endif
+						if (verbose) {
+								printf ("Illegal opcode: %02X %02X /%X @ %04X:%04X\n", getmem8(savecs, saveip), getmem8(savecs, saveip+1), (getmem8(savecs, saveip+2) >> 3) & 7, savecs, saveip);
+							}
+						break;
+				}
+
+skipexecution:
+			if (!running) {
+					return;
+				}
+		}
+}
+#endif
diff --git a/src/fake86/cpu.h b/src/fake86/cpu.h
new file mode 100755
index 0000000..6b37f47
--- /dev/null
+++ b/src/fake86/cpu.h
@@ -0,0 +1,110 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <time.h>
+#endif
+
+#define regax 0
+#define regcx 1
+#define regdx 2
+#define regbx 3
+#define regsp 4
+#define regbp 5
+#define regsi 6
+#define regdi 7
+#define reges 0
+#define regcs 1
+#define regss 2
+#define regds 3
+
+#ifdef __BIG_ENDIAN__
+#define regal 1
+#define regah 0
+#define regcl 3
+#define regch 2
+#define regdl 5
+#define regdh 4
+#define regbl 7
+#define regbh 6
+#else
+#define regal 0
+#define regah 1
+#define regcl 2
+#define regch 3
+#define regdl 4
+#define regdh 5
+#define regbl 6
+#define regbh 7
+#endif
+
+union _bytewordregs_ {
+	uint16_t wordregs[8];
+	uint8_t byteregs[8];
+};
+
+#ifdef CPU_ADDR_MODE_CACHE
+struct addrmodecache_s {
+	uint16_t exitcs;
+	uint16_t exitip;
+	uint16_t disp16;
+	uint32_t len;
+	uint8_t mode;
+	uint8_t reg;
+	uint8_t rm;
+	uint8_t forcess;
+	uint8_t valid;
+};
+#endif
+
+#define StepIP(x)	ip += x
+#define getmem8(x, y)	read86(segbase(x) + y)
+#define getmem16(x, y)	readw86(segbase(x) + y)
+#define putmem8(x, y, z)	write86(segbase(x) + y, z)
+#define putmem16(x, y, z)	writew86(segbase(x) + y, z)
+#define signext(value)	(int16_t)(int8_t)(value)
+#define signext32(value)	(int32_t)(int16_t)(value)
+#define getreg16(regid)	regs.wordregs[regid]
+#define getreg8(regid)	regs.byteregs[byteregtable[regid]]
+#define putreg16(regid, writeval)	regs.wordregs[regid] = writeval
+#define putreg8(regid, writeval)	regs.byteregs[byteregtable[regid]] = writeval
+#define getsegreg(regid)	segregs[regid]
+#define putsegreg(regid, writeval)	segregs[regid] = writeval
+#define segbase(x)	((uint32_t) x << 4)
+
+#define makeflagsword() \
+	( \
+	2 | (uint16_t) cf | ((uint16_t) pf << 2) | ((uint16_t) af << 4) | ((uint16_t) zf << 6) | ((uint16_t) sf << 7) | \
+	((uint16_t) tf << 8) | ((uint16_t) ifl << 9) | ((uint16_t) df << 10) | ((uint16_t) of << 11) \
+	)
+
+#define decodeflagsword(x) { \
+	temp16 = x; \
+	cf = temp16 & 1; \
+	pf = (temp16 >> 2) & 1; \
+	af = (temp16 >> 4) & 1; \
+	zf = (temp16 >> 6) & 1; \
+	sf = (temp16 >> 7) & 1; \
+	tf = (temp16 >> 8) & 1; \
+	ifl = (temp16 >> 9) & 1; \
+	df = (temp16 >> 10) & 1; \
+	of = (temp16 >> 11) & 1; \
+	}
diff --git a/src/fake86/disk.c b/src/fake86/disk.c
new file mode 100755
index 0000000..b09c8e2
--- /dev/null
+++ b/src/fake86/disk.c
@@ -0,0 +1,182 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* disk.c: disk emulation routines for Fake86. works at the BIOS interrupt 13h level. */
+
+#include <stdint.h>
+#include <stdio.h>
+#include "disk.h"
+#include "cpu.h"
+
+extern uint8_t RAM[0x100000], cf, hdcount;
+extern uint16_t segregs[4];
+extern union _bytewordregs_ regs;
+
+extern uint8_t read86 (uint32_t addr32);
+extern void write86 (uint32_t addr32, uint8_t value);
+
+struct struct_drive disk[256];
+uint8_t sectorbuffer[512];
+
+uint8_t insertdisk (uint8_t drivenum, char *filename) {
+	if (disk[drivenum].inserted) fclose (disk[drivenum].diskfile);
+	else disk[drivenum].inserted = 1;
+	disk[drivenum].diskfile = fopen (filename, "r+b");
+	if (disk[drivenum].diskfile==NULL) {
+			disk[drivenum].inserted = 0;
+			return (1);
+		}
+	fseek (disk[drivenum].diskfile, 0L, SEEK_END);
+	disk[drivenum].filesize = ftell (disk[drivenum].diskfile);
+	fseek (disk[drivenum].diskfile, 0L, SEEK_SET);
+	if (drivenum >= 0x80) { //it's a hard disk image
+			disk[drivenum].sects = 63;
+			disk[drivenum].heads = 16;
+			disk[drivenum].cyls = disk[drivenum].filesize / (disk[drivenum].sects * disk[drivenum].heads * 512);
+			hdcount++;
+		}
+	else {   //it's a floppy image
+			disk[drivenum].cyls = 80;
+			disk[drivenum].sects = 18;
+			disk[drivenum].heads = 2;
+			if (disk[drivenum].filesize <= 1228800) disk[drivenum].sects = 15;
+			if (disk[drivenum].filesize <= 737280) disk[drivenum].sects = 9;
+			if (disk[drivenum].filesize <= 368640) {
+					disk[drivenum].cyls = 40;
+					disk[drivenum].sects = 9;
+				}
+			if (disk[drivenum].filesize <= 163840) {
+					disk[drivenum].cyls = 40;
+					disk[drivenum].sects = 8;
+					disk[drivenum].heads = 1;
+				}
+		}
+	return (0);
+}
+
+void ejectdisk (uint8_t drivenum) {
+	disk[drivenum].inserted = 0;
+	if (disk[drivenum].diskfile != NULL) fclose (disk[drivenum].diskfile);
+}
+
+void readdisk (uint8_t drivenum, uint16_t dstseg, uint16_t dstoff, uint16_t cyl, uint16_t sect, uint16_t head, uint16_t sectcount) {
+	uint32_t memdest, lba, fileoffset, cursect, sectoffset;
+	if (!sect || !disk[drivenum].inserted) return;
+	lba = ( (uint32_t) cyl * (uint32_t) disk[drivenum].heads + (uint32_t) head) * (uint32_t) disk[drivenum].sects + (uint32_t) sect - 1;
+	fileoffset = lba * 512;
+	if (fileoffset>disk[drivenum].filesize) return;
+	fseek (disk[drivenum].diskfile, fileoffset, SEEK_SET);
+	memdest = ( (uint32_t) dstseg << 4) + (uint32_t) dstoff;
+	//for the readdisk function, we need to use write86 instead of directly fread'ing into
+	//the RAM array, so that read-only flags are honored. otherwise, a program could load
+	//data from a disk over BIOS or other ROM code that it shouldn't be able to.
+	for (cursect=0; cursect<sectcount; cursect++) {
+			if (fread (sectorbuffer, 1, 512, disk[drivenum].diskfile) < 512) break;
+			for (sectoffset=0; sectoffset<512; sectoffset++) {
+					write86 (memdest++, sectorbuffer[sectoffset]);
+				}
+		}
+	regs.byteregs[regal] = cursect;
+	cf = 0;
+	regs.byteregs[regah] = 0;
+}
+
+void writedisk (uint8_t drivenum, uint16_t dstseg, uint16_t dstoff, uint16_t cyl, uint16_t sect, uint16_t head, uint16_t sectcount) {
+	uint32_t memdest, lba, fileoffset, cursect, sectoffset;
+	if (!sect || !disk[drivenum].inserted) return;
+	lba = ( (uint32_t) cyl * (uint32_t) disk[drivenum].heads + (uint32_t) head) * (uint32_t) disk[drivenum].sects + (uint32_t) sect - 1;
+	fileoffset = lba * 512;
+	if (fileoffset>disk[drivenum].filesize) return;
+	fseek (disk[drivenum].diskfile, fileoffset, SEEK_SET);
+	memdest = ( (uint32_t) dstseg << 4) + (uint32_t) dstoff;
+	for (cursect=0; cursect<sectcount; cursect++) {
+			for (sectoffset=0; sectoffset<512; sectoffset++) {
+					sectorbuffer[sectoffset] = read86 (memdest++);
+				}
+			fwrite (sectorbuffer, 1, 512, disk[drivenum].diskfile);
+		}
+	regs.byteregs[regal] = (uint8_t) sectcount;
+	cf = 0;
+	regs.byteregs[regah] = 0;
+}
+
+void diskhandler() {
+	static uint8_t lastdiskah[256], lastdiskcf[256];
+	switch (regs.byteregs[regah]) {
+			case 0: //reset disk system
+				regs.byteregs[regah] = 0;
+				cf = 0; //useless function in an emulator. say success and return.
+				break;
+			case 1: //return last status
+				regs.byteregs[regah] = lastdiskah[regs.byteregs[regdl]];
+				cf = lastdiskcf[regs.byteregs[regdl]];
+				return;
+			case 2: //read sector(s) into memory
+				if (disk[regs.byteregs[regdl]].inserted) {
+						readdisk (regs.byteregs[regdl], segregs[reges], getreg16 (regbx), regs.byteregs[regch] + (regs.byteregs[regcl]/64) *256, regs.byteregs[regcl] & 63, regs.byteregs[regdh], regs.byteregs[regal]);
+						cf = 0;
+						regs.byteregs[regah] = 0;
+					}
+				else {
+						cf = 1;
+						regs.byteregs[regah] = 1;
+					}
+				break;
+			case 3: //write sector(s) from memory
+				if (disk[regs.byteregs[regdl]].inserted) {
+						writedisk (regs.byteregs[regdl], segregs[reges], getreg16 (regbx), regs.byteregs[regch] + (regs.byteregs[regcl]/64) *256, regs.byteregs[regcl] & 63, regs.byteregs[regdh], regs.byteregs[regal]);
+						cf = 0;
+						regs.byteregs[regah] = 0;
+					}
+				else {
+						cf = 1;
+						regs.byteregs[regah] = 1;
+					}
+				break;
+			case 4:
+			case 5: //format track
+				cf = 0;
+				regs.byteregs[regah] = 0;
+				break;
+			case 8: //get drive parameters
+				if (disk[regs.byteregs[regdl]].inserted) {
+						cf = 0;
+						regs.byteregs[regah] = 0;
+						regs.byteregs[regch] = disk[regs.byteregs[regdl]].cyls - 1;
+						regs.byteregs[regcl] = disk[regs.byteregs[regdl]].sects & 63;
+						regs.byteregs[regcl] = regs.byteregs[regcl] + (disk[regs.byteregs[regdl]].cyls/256) *64;
+						regs.byteregs[regdh] = disk[regs.byteregs[regdl]].heads - 1;
+						if (regs.byteregs[regdl]<0x80) {
+								regs.byteregs[regbl] = 4; //else regs.byteregs[regbl] = 0;
+								regs.byteregs[regdl] = 2;
+							}
+						else regs.byteregs[regdl] = hdcount;
+					}
+				else {
+						cf = 1;
+						regs.byteregs[regah] = 0xAA;
+					}
+				break;
+			default:
+				cf = 1;
+		}
+	lastdiskah[regs.byteregs[regdl]] = regs.byteregs[regah];
+	lastdiskcf[regs.byteregs[regdl]] = cf;
+	if (regs.byteregs[regdl] & 0x80) RAM[0x474] = regs.byteregs[regah];
+}
diff --git a/src/fake86/disk.h b/src/fake86/disk.h
new file mode 100755
index 0000000..34f062a
--- /dev/null
+++ b/src/fake86/disk.h
@@ -0,0 +1,31 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include <stdint.h>
+#include <stdio.h>
+
+struct struct_drive {
+	FILE *diskfile;
+	uint32_t filesize;
+	uint16_t cyls;
+	uint16_t sects;
+	uint16_t heads;
+	uint8_t inserted;
+	char *filename;
+};
diff --git a/src/fake86/i8237.c b/src/fake86/i8237.c
new file mode 100755
index 0000000..2ad9498
--- /dev/null
+++ b/src/fake86/i8237.c
@@ -0,0 +1,133 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* i8237.c: functions to emulate the Intel 8237 DMA controller.
+   the Sound Blaster emulation functions rely on this! */
+
+#include "config.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <memory.h>
+#include "blaster.h"
+#include "i8237.h"
+
+extern struct blaster_s blaster;
+
+struct dmachan_s dmachan[4];
+uint8_t flipflop = 0;
+
+extern void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern uint8_t read86 (uint32_t addr32);
+
+extern uint8_t RAM[0x100000];
+uint8_t read8237 (uint8_t channel) {
+	uint8_t ret;
+	if (dmachan[channel].masked) return (128);
+	if (dmachan[channel].autoinit && (dmachan[channel].count > dmachan[channel].reload) ) dmachan[channel].count = 0;
+	if (dmachan[channel].count > dmachan[channel].reload) return (128);
+	//if (dmachan[channel].direction) ret = RAM[dmachan[channel].page + dmachan[channel].addr + dmachan[channel].count];
+	//	else ret = RAM[dmachan[channel].page + dmachan[channel].addr - dmachan[channel].count];
+	if (dmachan[channel].direction == 0) ret = RAM[dmachan[channel].page + dmachan[channel].addr + dmachan[channel].count];
+	else ret = RAM[dmachan[channel].page + dmachan[channel].addr - dmachan[channel].count];
+	dmachan[channel].count++;
+	return (ret);
+}
+
+void out8237 (uint16_t addr, uint8_t value) {
+	uint8_t channel;
+#ifdef DEBUG_DMA
+	printf ("out8237(0x%X, %X);\n", addr, value);
+#endif
+	switch (addr) {
+			case 0x2: //channel 1 address register
+				if (flipflop == 1) dmachan[1].addr = (dmachan[1].addr & 0x00FF) | ( (uint32_t) value << 8);
+				else dmachan[1].addr = (dmachan[1].addr & 0xFF00) | value;
+#ifdef DEBUG_DMA
+				if (flipflop == 1) printf ("[NOTICE] DMA channel 1 address register = %04X\n", dmachan[1].addr);
+#endif
+				flipflop = ~flipflop & 1;
+				break;
+			case 0x3: //channel 1 count register
+				if (flipflop == 1) dmachan[1].reload = (dmachan[1].reload & 0x00FF) | ( (uint32_t) value << 8);
+				else dmachan[1].reload = (dmachan[1].reload & 0xFF00) | value;
+				if (flipflop == 1) {
+						if (dmachan[1].reload == 0) dmachan[1].reload = 65536;
+						dmachan[1].count = 0;
+#ifdef DEBUG_DMA
+						printf ("[NOTICE] DMA channel 1 reload register = %04X\n", dmachan[1].reload);
+#endif
+					}
+				flipflop = ~flipflop & 1;
+				break;
+			case 0xA: //write single mask register
+				channel = value & 3;
+				dmachan[channel].masked = (value >> 2) & 1;
+#ifdef DEBUG_DMA
+				printf ("[NOTICE] DMA channel %u masking = %u\n", channel, dmachan[channel].masked);
+#endif
+				break;
+			case 0xB: //write mode register
+				channel = value & 3;
+				dmachan[channel].direction = (value >> 5) & 1;
+				dmachan[channel].autoinit = (value >> 4) & 1;
+				dmachan[channel].writemode = (value >> 2) & 1; //not quite accurate
+#ifdef DEBUG_DMA
+				printf ("[NOTICE] DMA channel %u write mode reg: direction = %u, autoinit = %u, write mode = %u\n",
+				        channel, dmachan[channel].direction, dmachan[channel].autoinit, dmachan[channel].writemode);
+#endif
+				break;
+			case 0xC: //clear byte pointer flip-flop
+#ifdef DEBUG_DMA
+				printf ("[NOTICE] DMA cleared byte pointer flip-flop\n");
+#endif
+				flipflop = 0;
+				break;
+			case 0x83: //DMA channel 1 page register
+				dmachan[1].page = (uint32_t) value << 16;
+#ifdef DEBUG_DMA
+				printf ("[NOTICE] DMA channel 1 page base = %05X\n", dmachan[1].page);
+#endif
+				break;
+		}
+}
+
+uint8_t in8237 (uint16_t addr) {
+#ifdef DEBUG_DMA
+	printf ("in8237(0x%X);\n", addr);
+#endif
+	switch (addr) {
+		case 3:
+			if (flipflop == 1) return(dmachan[1].reload >> 8);
+			else return(dmachan[1].reload);
+			flipflop = ~flipflop & 1;
+			break;
+	}
+	return (0);
+}
+
+void init8237() {
+	memset (dmachan, 0, sizeof (dmachan) );
+
+	set_port_write_redirector (0x00, 0x0F, &out8237);
+	set_port_read_redirector (0x00, 0x0F, &in8237);
+
+	set_port_write_redirector (0x80, 0x8F, &out8237);
+	set_port_read_redirector (0x80, 0x8F, &in8237);
+}
diff --git a/src/fake86/i8237.h b/src/fake86/i8237.h
new file mode 100755
index 0000000..ea2e24e
--- /dev/null
+++ b/src/fake86/i8237.h
@@ -0,0 +1,31 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include <stdint.h>
+
+struct dmachan_s {
+	uint32_t page;
+	uint32_t addr;
+	uint32_t reload;
+	uint32_t count;
+	uint8_t direction;
+	uint8_t autoinit;
+	uint8_t writemode;
+	uint8_t masked;
+};
diff --git a/src/fake86/i8253.c b/src/fake86/i8253.c
new file mode 100755
index 0000000..49d30e1
--- /dev/null
+++ b/src/fake86/i8253.c
@@ -0,0 +1,94 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* i8253.c: functions to emulate the Intel 8253 programmable interval timer.
+   these are required for the timer interrupt and PC speaker to be
+   properly emulated! */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <memory.h>
+#include "i8253.h"
+#include "mutex.h"
+
+extern void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback);
+
+struct i8253_s i8253;
+
+extern uint64_t hostfreq, lasttick, curtick, tickgap, totalexec;
+
+void out8253 (uint16_t portnum, uint8_t value) {
+	uint8_t curbyte;
+	portnum &= 3;
+	switch (portnum) {
+			case 0:
+			case 1:
+			case 2: //channel data
+				if ( (i8253.accessmode[portnum] == PIT_MODE_LOBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 0) ) ) curbyte = 0;
+				else if ( (i8253.accessmode[portnum] == PIT_MODE_HIBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 1) ) ) curbyte = 1;
+				if (curbyte == 0) { //low byte
+						i8253.chandata[portnum] = (i8253.chandata[portnum] & 0xFF00) | value;
+					}
+				else {   //high byte
+						i8253.chandata[portnum] = (i8253.chandata[portnum] & 0x00FF) | ( (uint16_t) value << 8);
+					}
+				if (i8253.chandata[portnum] == 0) i8253.effectivedata[portnum] = 65536;
+				else i8253.effectivedata[portnum] = i8253.chandata[portnum];
+				i8253.active[portnum] = 1;
+				tickgap = (uint64_t) ( (float) hostfreq / (float) ( (float) 1193182 / (float) i8253.effectivedata[0]) );
+				if (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) i8253.bytetoggle[portnum] = (~i8253.bytetoggle[portnum]) & 1;
+				i8253.chanfreq[portnum] = (float) ( (uint32_t) ( ( (float) 1193182.0 / (float) i8253.effectivedata[portnum]) * (float) 1000.0) ) / (float) 1000.0;
+				//printf("[DEBUG] PIT channel %u counter changed to %u (%f Hz)\n", portnum, i8253.chandata[portnum], i8253.chanfreq[portnum]);
+				break;
+			case 3: //mode/command
+				i8253.accessmode[value>>6] = (value >> 4) & 3;
+				if (i8253.accessmode[value>>6] == PIT_MODE_TOGGLE) i8253.bytetoggle[value>>6] = 0;
+				break;
+		}
+}
+
+uint8_t in8253 (uint16_t portnum) {
+	uint8_t curbyte;
+	portnum &= 3;
+	switch (portnum) {
+			case 0:
+			case 1:
+			case 2: //channel data
+				if ( (i8253.accessmode[portnum] == 0) || (i8253.accessmode[portnum] == PIT_MODE_LOBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 0) ) ) curbyte = 0;
+				else if ( (i8253.accessmode[portnum] == PIT_MODE_HIBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 1) ) ) curbyte = 1;
+				if ( (i8253.accessmode[portnum] == 0) || (i8253.accessmode[portnum] == PIT_MODE_LOBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 0) ) ) curbyte = 0;
+				else if ( (i8253.accessmode[portnum] == PIT_MODE_HIBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 1) ) ) curbyte = 1;
+				if ( (i8253.accessmode[portnum] == 0) || (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) ) i8253.bytetoggle[portnum] = (~i8253.bytetoggle[portnum]) & 1;
+				if (curbyte == 0) { //low byte
+						return ( (uint8_t) i8253.counter[portnum]);
+					}
+				else {   //high byte
+						return ( (uint8_t) (i8253.counter[portnum] >> 8) );
+					}
+				break;
+		}
+	return (0);
+}
+
+void init8253() {
+	memset (&i8253, 0, sizeof (i8253) );
+	set_port_write_redirector (0x40, 0x43, &out8253);
+	set_port_read_redirector (0x40, 0x43, &in8253);
+}
diff --git a/src/fake86/i8253.h b/src/fake86/i8253.h
new file mode 100755
index 0000000..de28ccd
--- /dev/null
+++ b/src/fake86/i8253.h
@@ -0,0 +1,33 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#define PIT_MODE_LATCHCOUNT	0
+#define PIT_MODE_LOBYTE	1
+#define PIT_MODE_HIBYTE	2
+#define PIT_MODE_TOGGLE	3
+
+struct i8253_s {
+	uint16_t chandata[3];
+	uint8_t accessmode[3];
+	uint8_t bytetoggle[3];
+	uint32_t effectivedata[3];
+	float chanfreq[3];
+	uint8_t active[3];
+	uint16_t counter[3];
+};
diff --git a/src/fake86/i8259.c b/src/fake86/i8259.c
new file mode 100755
index 0000000..97a297a
--- /dev/null
+++ b/src/fake86/i8259.c
@@ -0,0 +1,99 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* i8259.c: functions to emulate the Intel 8259 prioritized interrupt controller.
+   note: this is not a very complete 8259 implementation, but for the purposes
+   of a PC, it's all we need. */
+
+#include <stdint.h>
+#include <string.h>
+#include "i8259.h"
+
+struct structpic i8259;
+
+extern uint8_t keyboardwaitack;
+
+extern void set_port_write_redirector(uint16_t startport, uint16_t endport, void *callback);
+extern void set_port_read_redirector(uint16_t startport, uint16_t endport, void *callback);
+
+uint8_t in8259(uint16_t portnum) {
+	switch (portnum & 1) {
+		   case 0:
+			if (i8259.readmode==0) return(i8259.irr); else return(i8259.isr);
+		   case 1: //read mask register
+			return(i8259.imr);
+	}
+	return (0);
+}
+
+extern uint32_t makeupticks;
+void out8259(uint16_t portnum, uint8_t value) {
+	 uint8_t i;
+	 switch (portnum & 1) {
+		case 0:
+		 if (value & 0x10) { //begin initialization sequence
+			i8259.icwstep = 1;
+			i8259.imr = 0; //clear interrupt mask register
+			i8259.icw[i8259.icwstep++] = value;
+			return;
+		 }
+		 if ((value & 0x98)==8) { //it's an OCW3
+			if (value & 2) i8259.readmode = value & 2;
+		 }
+		 if (value & 0x20) { //EOI command
+	keyboardwaitack = 0;
+			for (i=0; i<8; i++)
+			if ((i8259.isr >> i) & 1) {
+			   i8259.isr ^= (1 << i);
+			   if ((i==0) && (makeupticks>0)) { makeupticks = 0; i8259.irr |= 1; }
+			   return;
+			}
+		 }
+		 break;
+		case 1:
+		 if ((i8259.icwstep==3) && (i8259.icw[1] & 2)) i8259.icwstep = 4; //single mode, so don't read ICW3
+		 if (i8259.icwstep<5) { i8259.icw[i8259.icwstep++] = value; return; }
+		 //if we get to this point, this is just a new IMR value
+		 i8259.imr = value;
+		 break;
+	 }
+}
+
+uint8_t nextintr() {
+	uint8_t i, tmpirr;
+	tmpirr = i8259.irr & (~i8259.imr); //XOR request register with inverted mask register
+	for (i=0; i<8; i++)
+		if ((tmpirr >> i) & 1) {
+		   i8259.irr ^= (1 << i);
+		   i8259.isr |= (1 << i);
+		   return(i8259.icw[2] + i);
+		}
+	return(0); //this won't be reached, but without it the compiler gives a warning
+}
+
+void doirq(uint8_t irqnum) {
+	 i8259.irr |= (1 << irqnum);
+	 if (irqnum == 1) keyboardwaitack = 1;
+}
+
+void init8259() {
+	 memset((void *)&i8259, 0, sizeof(i8259));
+	 set_port_write_redirector(0x20, 0x21, &out8259);
+	 set_port_read_redirector(0x20, 0x21, &in8259);
+}
diff --git a/src/fake86/i8259.h b/src/fake86/i8259.h
new file mode 100755
index 0000000..4056184
--- /dev/null
+++ b/src/fake86/i8259.h
@@ -0,0 +1,31 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+struct structpic {
+	uint8_t imr; //mask register
+	uint8_t irr; //request register
+	uint8_t isr; //service register
+	uint8_t icwstep; //used during initialization to keep track of which ICW we're at
+	uint8_t icw[5];
+	uint8_t intoffset; //interrupt vector offset
+	uint8_t priority; //which IRQ has highest priority
+	uint8_t autoeoi; //automatic EOI mode
+	uint8_t readmode; //remember what to return on read register from OCW3
+	uint8_t enabled;
+};
diff --git a/src/fake86/input.c b/src/fake86/input.c
new file mode 100755
index 0000000..f92428d
--- /dev/null
+++ b/src/fake86/input.c
@@ -0,0 +1,361 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* input.c: functions for translation of SDL scancodes to BIOS scancodes,
+   and handling of SDL events in general. */
+
+#include <SDL/SDL.h>
+#include <stdint.h>
+#include "sermouse.h"
+
+uint8_t keydown[0x100], keyboardwaitack = 0;
+extern uint32_t usegrabmode;
+
+extern void doirq (uint8_t irqnum);
+extern uint8_t running, portram[0x10000];
+extern SDL_Surface *screen;
+
+uint8_t translatescancode (uint16_t keyval) {
+	switch (keyval) {
+			case 0x1B:
+				return (1);
+				break; //Esc
+			case 0x30:
+				return (0xB);
+				break; //zero
+			case 0x31:
+			case 0x32:
+			case 0x33:
+			case 0x34:
+			case 0x35:
+			case 0x36:
+			case 0x37:
+			case 0x38:
+			case 0x39:
+				return (keyval - 0x2F);
+				break; //other number keys
+			case 0x2D:
+				return (0xC);
+				break; //-_
+			case 0x3D:
+				return (0xD);
+				break; //=+
+			case 0x8:
+				return (0xE);
+				break; //backspace
+			case 0x9:
+				return (0xF);
+				break; //tab
+			case 0x71:
+				return (0x10);
+				break;
+			case 0x77:
+				return (0x11);
+				break;
+			case 0x65:
+				return (0x12);
+				break;
+			case 0x72:
+				return (0x13);
+				break;
+			case 0x74:
+				return (0x14);
+				break;
+			case 0x79:
+				return (0x15);
+				break;
+			case 0x75:
+				return (0x16);
+				break;
+			case 0x69:
+				return (0x17);
+				break;
+			case 0x6F:
+				return (0x18);
+				break;
+			case 0x70:
+				return (0x19);
+				break;
+			case 0x5B:
+				return (0x1A);
+				break;
+			case 0x5D:
+				return (0x1B);
+				break;
+			case 0xD:
+			case 0x10F:
+				return (0x1C);
+				break; //enter
+			case 0x131:
+			case 0x132:
+				return (0x1D);
+				break; //ctrl
+			case 0x61:
+				return (0x1E);
+				break;
+			case 0x73:
+				return (0x1F);
+				break;
+			case 0x64:
+				return (0x20);
+				break;
+			case 0x66:
+				return (0x21);
+				break;
+			case 0x67:
+				return (0x22);
+				break;
+			case 0x68:
+				return (0x23);
+				break;
+			case 0x6A:
+				return (0x24);
+				break;
+			case 0x6B:
+				return (0x25);
+				break;
+			case 0x6C:
+				return (0x26);
+				break;
+			case 0x3B:
+				return (0x27);
+				break;
+			case 0x27:
+				return (0x28);
+				break;
+			case 0x60:
+				return (0x29);
+				break;
+			case 0x130:
+				return (0x2A);
+				break; //left shift
+			case 0x5C:
+				return (0x2B);
+				break;
+			case 0x7A:
+				return (0x2C);
+				break;
+			case 0x78:
+				return (0x2D);
+				break;
+			case 0x63:
+				return (0x2E);
+				break;
+			case 0x76:
+				return (0x2F);
+				break;
+			case 0x62:
+				return (0x30);
+				break;
+			case 0x6E:
+				return (0x31);
+				break;
+			case 0x6D:
+				return (0x32);
+				break;
+			case 0x2C:
+				return (0x33);
+				break;
+			case 0x2E:
+				return (0x34);
+				break;
+			case 0x2F:
+				return (0x35);
+				break;
+			case 0x12F:
+				return (0x36);
+				break; //right shift
+			case 0x13C:
+				return (0x37);
+				break; //print screen
+			case 0x133:
+			case 0x134:
+				return (0x38);
+				break; //alt
+			case 0x20:
+				return (0x39);
+				break; //space
+			case 0x12D:
+				return (0x3A);
+				break; //caps lock
+			case 0x11A:
+			case 0x11B:
+			case 0x11C:
+			case 0x11D:
+			case 0x11E:
+			case 0x11F:
+			case 0x120:
+			case 0x121:
+			case 0x122:
+			case 0x123:
+				return (keyval - 0x11A + 0x3B);
+				break; //F1 to F10
+			case 0x12C:
+				return (0x45);
+				break; //num lock
+			case 0x12E:
+				return (0x46);
+				break; //scroll lock
+			case 0x116:
+			case 0x107:
+				return (0x47);
+				break; //home
+			case 0x111:
+			case 0x108:
+				return (0x48);
+				break; //up
+			case 0x118:
+			case 0x109:
+				return (0x49);
+				break; //pgup
+			case 0x10D:
+				return (0x4A);
+				break; //keypad -
+			case 0x114:
+			case 0x104:
+				return (0x4B);
+				break; //left
+			case 0x105:
+				return (0x4C);
+				break; //center
+			case 0x113:
+			case 0x106:
+				return (0x4D);
+				break; //right
+			case 0x10E:
+				return (0x4E);
+				break; //keypad +
+			case 0x117:
+			case 0x101:
+				return (0x4F);
+				break; //end
+			case 0x112:
+			case 0x102:
+				return (0x50);
+				break; //down
+			case 0x119:
+			case 0x103:
+				return (0x51);
+				break; //pgdn
+			case 0x115:
+			case 0x100:
+				return (0x52);
+				break; //ins
+			case 0x7F:
+			case 0x10A:
+				return (0x53);
+				break; //del
+			default:
+				return (0);
+		}
+}
+
+uint8_t buttons = 0;
+extern void sermouseevent (uint8_t buttons, int8_t xrel, int8_t yrel);
+extern struct sermouse_s sermouse;
+extern void setwindowtitle (uint8_t *extra);
+
+void mousegrabtoggle() {
+	if (usegrabmode == SDL_GRAB_ON) {
+			usegrabmode = SDL_GRAB_OFF;
+			SDL_WM_GrabInput (SDL_GRAB_OFF);
+			SDL_ShowCursor (SDL_ENABLE);
+			setwindowtitle ("");
+		}
+	else {
+			usegrabmode = SDL_GRAB_ON;
+			SDL_WM_GrabInput (SDL_GRAB_ON);
+			SDL_ShowCursor (SDL_DISABLE);
+			setwindowtitle (" (press Ctrl + Alt to release mouse)");
+		}
+}
+
+extern uint8_t scrmodechange;
+extern uint32_t usefullscreen;
+void handleinput() {
+	SDL_Event event;
+	int mx = 0, my = 0;
+	uint8_t tempbuttons;
+	if (SDL_PollEvent (&event) ) {
+			switch (event.type) {
+					case SDL_KEYDOWN:
+						portram[0x60] = translatescancode (event.key.keysym.sym);
+						portram[0x64] |= 2;
+						doirq (1);
+						//printf("%02X\n", translatescancode(event.key.keysym.sym));
+						keydown[translatescancode (event.key.keysym.sym) ] = 1;
+						if (keydown[0x38] && keydown[0x1D] && (SDL_WM_GrabInput (SDL_GRAB_QUERY) == SDL_GRAB_ON) ) {
+								keydown[0x1D] = 0;
+								keydown[0x32] = 0;
+								mousegrabtoggle();
+								break;
+							}
+						if (keydown[0x38] && keydown[0x1C]) {
+								keydown[0x1D] = 0;
+								keydown[0x38] = 0;
+								if (usefullscreen) usefullscreen = 0;
+								else usefullscreen = SDL_FULLSCREEN;
+								scrmodechange = 1;
+								break;
+							}
+						break;
+					case SDL_KEYUP:
+						portram[0x60] = translatescancode (event.key.keysym.sym) | 0x80;
+						portram[0x64] |= 2;
+						doirq (1);
+						keydown[translatescancode (event.key.keysym.sym) ] = 0;
+						break;
+					case SDL_MOUSEBUTTONDOWN:
+						if (SDL_WM_GrabInput (SDL_GRAB_QUERY) == SDL_GRAB_OFF) {
+								mousegrabtoggle();
+								break;
+							}
+						tempbuttons = SDL_GetMouseState (NULL, NULL);
+						if (tempbuttons & 1) buttons = 2;
+						else buttons = 0;
+						if (tempbuttons & 4) buttons |= 1;
+						sermouseevent (buttons, 0, 0);
+						break;
+					case SDL_MOUSEBUTTONUP:
+						if (SDL_WM_GrabInput (SDL_GRAB_QUERY) == SDL_GRAB_OFF) break;
+						tempbuttons = SDL_GetMouseState (NULL, NULL);
+						if (tempbuttons & 1) buttons = 2;
+						else buttons = 0;
+						if (tempbuttons & 4) buttons |= 1;
+						sermouseevent (buttons, 0, 0);
+						break;
+					case SDL_MOUSEMOTION:
+						if (SDL_WM_GrabInput (SDL_GRAB_QUERY) == SDL_GRAB_OFF) break;
+						SDL_GetRelativeMouseState (&mx, &my);
+						sermouseevent (buttons, (int8_t) mx, (int8_t) my);
+						SDL_WarpMouse (screen->w / 2, screen->h / 2);
+						while (1) {
+								SDL_PollEvent (&event);
+								SDL_GetRelativeMouseState (&mx, &my);
+								if ( (mx == 0) && (my == 0) ) break;
+							}
+						break;
+					case SDL_QUIT:
+						running = 0;
+						break;
+					default:
+						break;
+				}
+		}
+}
diff --git a/src/fake86/main.c b/src/fake86/main.c
new file mode 100755
index 0000000..78b3c43
--- /dev/null
+++ b/src/fake86/main.c
@@ -0,0 +1,321 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* main.c: functions to initialize the different components of Fake86,
+   load ROM binaries, and kickstart the CPU emulator. */
+
+#include "config.h"
+#ifdef __APPLE__      /* Memory leaks occur in OS X when the SDL window gets */
+#include <SDL/SDL.h>  /* resized if SDL.h not included in file with main() */
+#endif
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include "mutex.h"
+#ifdef _WIN32
+CRITICAL_SECTION screenmutex;
+#else
+#ifndef __APPLE__
+#include <X11/Xlib.h>
+#endif
+pthread_t consolethread;
+#endif
+
+const uint8_t *build = BUILD_STRING;
+
+extern uint8_t RAM[0x100000], readonly[0x100000];
+extern uint8_t running, renderbenchmark;
+
+extern void reset86();
+extern void exec86 (uint32_t execloops);
+extern uint8_t initscreen (uint8_t *ver);
+extern void VideoThread();
+extern doscrmodechange();
+extern void handleinput();
+
+#ifdef CPU_ADDR_MODE_CACHE
+extern uint64_t cached_access_count, uncached_access_count;
+#endif
+
+extern uint8_t scrmodechange, doaudio;
+extern uint64_t totalexec, totalframes;
+uint64_t starttick, endtick, lasttick;
+
+uint8_t *biosfile = NULL, verbose = 0, cgaonly = 0, useconsole = 0;
+uint32_t speed = 0;
+
+
+uint32_t loadbinary (uint32_t addr32, uint8_t *filename, uint8_t roflag) {
+	FILE *binfile = NULL;
+	uint32_t readsize;
+
+	binfile = fopen (filename, "rb");
+	if (binfile == NULL) {
+			return (0);
+		}
+
+	fseek (binfile, 0, SEEK_END);
+	readsize = ftell (binfile);
+	fseek (binfile, 0, SEEK_SET);
+	fread ( (void *) &RAM[addr32], 1, readsize, binfile);
+	fclose (binfile);
+
+	memset ( (void *) &readonly[addr32], roflag, readsize);
+	return (readsize);
+}
+
+uint32_t loadrom (uint32_t addr32, uint8_t *filename, uint8_t failure_fatal) {
+	uint32_t readsize;
+	readsize = loadbinary (addr32, filename, 1);
+	if (!readsize) {
+			if (failure_fatal) printf("FATAL: ");
+			else printf("WARNING: ");
+			printf ("Unable to load %s\n", filename);
+			return (0);
+		}
+	else {
+			printf ("Loaded %s at 0x%05X (%lu KB)\n", filename, addr32, readsize >> 10);
+			return (readsize);
+		}
+}
+
+uint32_t loadbios (uint8_t *filename) {
+	FILE *binfile = NULL;
+	uint32_t readsize;
+
+	binfile = fopen (filename, "rb");
+	if (binfile == NULL) {
+			return (0);
+		}
+
+	fseek (binfile, 0, SEEK_END);
+	readsize = ftell (binfile);
+	fseek (binfile, 0, SEEK_SET);
+	fread ( (void *) &RAM[0x100000 - readsize], 1, readsize, binfile);
+	fclose (binfile);
+
+	memset ( (void *) &readonly[0x100000 - readsize], 1, readsize);
+	return (readsize);
+}
+
+extern uint32_t SDL_GetTicks();
+extern uint8_t insertdisk (uint8_t drivenum, char *filename);
+extern void ejectdisk (uint8_t drivenum);
+extern uint8_t bootdrive, ethif, net_enabled;
+extern void doirq (uint8_t irqnum);
+//extern void isa_ne2000_init(int baseport, uint8_t irq);
+extern void parsecl (int argc, char *argv[]);
+void timing();
+void tickaudio();
+void inittiming();
+void initaudio();
+void init8253();
+void init8259();
+extern void init8237();
+extern void initVideoPorts();
+extern void killaudio();
+extern void initsermouse (uint16_t baseport, uint8_t irq);
+extern void *port_write_callback[0x10000];
+extern void *port_read_callback[0x10000];
+extern void *port_write_callback16[0x10000];
+extern void *port_read_callback16[0x10000];
+extern void initadlib (uint16_t baseport);
+extern void initsoundsource();
+extern void isa_ne2000_init (uint16_t baseport, uint8_t irq);
+extern void initBlaster (uint16_t baseport, uint8_t irq);
+
+#ifdef NETWORKING_ENABLED
+extern void initpcap();
+extern void dispatch();
+#endif
+
+void printbinary (uint8_t value) {
+	int8_t curbit;
+
+	for (curbit=7; curbit>=0; curbit--) {
+			if ( (value >> curbit) & 1) printf ("1");
+			else printf ("0");
+		}
+}
+
+uint8_t usessource = 0;
+void inithardware() {
+#ifdef NETWORKING_ENABLED
+	if (ethif != 254) initpcap();
+#endif
+	printf ("Initializing emulated hardware:\n");
+	memset (port_write_callback, 0, sizeof (port_write_callback) );
+	memset (port_read_callback, 0, sizeof (port_read_callback) );
+	memset (port_write_callback16, 0, sizeof (port_write_callback16) );
+	memset (port_read_callback16, 0, sizeof (port_read_callback16) );
+	printf ("  - Intel 8253 timer: ");
+	init8253();
+	printf ("OK\n");
+	printf ("  - Intel 8259 interrupt controller: ");
+	init8259();
+	printf ("OK\n");
+	printf ("  - Intel 8237 DMA controller: ");
+	init8237();
+	printf ("OK\n");
+	initVideoPorts();
+	if (usessource) {
+			printf ("  - Disney Sound Source: ");
+			initsoundsource();
+			printf ("OK\n");
+		}
+#ifndef NETWORKING_OLDCARD
+	printf ("  - Novell NE2000 ethernet adapter: ");
+	isa_ne2000_init (0x300, 6);
+	printf ("OK\n");
+#endif
+	printf ("  - Adlib FM music card: ");
+	initadlib (0x388);
+	printf ("OK\n");
+	printf ("  - Creative Labs Sound Blaster 2.0: ");
+	initBlaster (0x220, 7);
+	printf ("OK\n");
+	printf ("  - Serial mouse (Microsoft compatible): ");
+	initsermouse (0x3F8, 4);
+	printf ("OK\n");
+	if (doaudio) initaudio();
+	inittiming();
+	initscreen ( (uint8_t *) build);
+}
+
+uint8_t dohardreset = 0;
+uint8_t audiobufferfilled();
+
+#ifdef _WIN32
+void initmenus();
+void EmuThread (void *dummy) {
+#else
+pthread_t emuthread;
+void *EmuThread (void *dummy) {
+#endif
+	while (running) {
+			if (!speed) exec86 (10000);
+			else {
+				exec86(speed / 100);
+				while (!audiobufferfilled()) {
+					timing();
+					tickaudio();
+				}
+#ifdef _WIN32
+				Sleep(10);
+#else
+				usleep(10000);
+#endif
+			}
+			if (scrmodechange) doscrmodechange();
+			if (dohardreset) {
+				reset86();
+				dohardreset = 0;
+			}
+		}
+}
+
+#ifdef _WIN32
+void runconsole (void *dummy);
+#else
+void *runconsole (void *dummy);
+#endif
+extern void bufsermousedata (uint8_t value);
+int main (int argc, char *argv[]) {
+	uint32_t biossize;
+
+	printf ("%s (c)2010-2013 Mike Chambers\n", build);
+	printf ("[A portable, open-source 8086 PC emulator]\n\n");
+
+	parsecl (argc, argv);
+
+	memset (readonly, 0, 0x100000);
+	biossize = loadbios (biosfile);
+	if (!biossize) return (-1);
+#ifdef DISK_CONTROLLER_ATA
+	if (!loadrom (0xD0000UL, PATH_DATAFILES "ide_xt.bin", 1) ) return (-1);
+#endif
+	if (biossize <= 8192) {
+		loadrom (0xF6000UL, PATH_DATAFILES "rombasic.bin", 0);
+		if (!loadrom (0xC0000UL, PATH_DATAFILES "videorom.bin", 1) ) return (-1);
+	}
+	printf ("\nInitializing CPU... ");
+	running = 1;
+	reset86();
+	printf ("OK!\n");
+
+#ifndef _WIN32
+#ifndef __APPLE__
+	XInitThreads();
+#endif
+#endif
+	inithardware();
+
+#ifdef _WIN32
+	initmenus();
+	InitializeCriticalSection (&screenmutex);
+#endif
+	if (useconsole) {
+#ifdef _WIN32
+			_beginthread (runconsole, 0, NULL);
+#else
+			pthread_create (&consolethread, NULL, (void *) runconsole, NULL);
+#endif
+		}
+
+#ifdef _WIN32
+			_beginthread (EmuThread, 0, NULL);
+#else
+			pthread_create (&emuthread, NULL, (void *) EmuThread, NULL);
+#endif
+
+	lasttick = starttick = SDL_GetTicks();
+	while (running) {
+			handleinput();
+#ifdef NETWORKING_ENABLED
+			if (ethif < 254) dispatch();
+#endif
+#ifdef _WIN32
+			Sleep(1);
+#else
+			usleep(1000);
+#endif
+	}
+	endtick = (SDL_GetTicks() - starttick) / 1000;
+	if (endtick == 0) endtick = 1; //avoid divide-by-zero exception in the code below, if ran for less than 1 second
+
+	killaudio();
+
+	if (renderbenchmark) {
+			printf ("\n%llu frames rendered in %llu seconds.\n", totalframes, endtick);
+			printf ("Average framerate: %llu FPS.\n", totalframes / endtick);
+		}
+
+	printf ("\n%llu instructions executed in %llu seconds.\n", totalexec, endtick);
+	printf ("Average speed: %llu instructions/second.\n", totalexec / endtick);
+
+#ifdef CPU_ADDR_MODE_CACHE
+	printf ("\n  Cached modregrm data access count: %llu\n", cached_access_count);
+	printf ("Uncached modregrm data access count: %llu\n", uncached_access_count);
+#endif
+
+	if (useconsole)	exit (0); //makes sure console thread quits even if blocking
+
+	return (0);
+}
diff --git a/src/fake86/modregrm.h b/src/fake86/modregrm.h
new file mode 100644
index 0000000..026e030
--- /dev/null
+++ b/src/fake86/modregrm.h
@@ -0,0 +1,129 @@
+#include "config.h"
+
+#ifdef CPU_ADDR_MODE_CACHE
+struct addrmodecache_s addrcache[0x100000];
+uint8_t addrcachevalid[0x100000];
+
+uint32_t addrdatalen, dataisvalid, setvalidptr;
+uint64_t cached_access_count = 0, uncached_access_count = 0;
+#define modregrm() { \
+	tempaddr32 = (((uint32_t)savecs << 4) + ip) & 0xFFFFF; \
+	if (addrcachevalid[tempaddr32]) { \
+		switch (addrcache[tempaddr32].len) { \
+			case 0: \
+				dataisvalid = 1; \
+				break; \
+			case 1: \
+				if (addrcachevalid[tempaddr32+1]) dataisvalid = 1; else dataisvalid = 0; \
+				break; \
+			case 2: \
+				if (addrcachevalid[tempaddr32+1] && addrcachevalid[tempaddr32+2]) dataisvalid = 1; else dataisvalid = 0; \
+				break; \
+		} \
+	} else dataisvalid = 0; \
+	if (dataisvalid) { \
+		cached_access_count++; \
+		disp16 = addrcache[tempaddr32].disp16; \
+		segregs[regcs] = addrcache[tempaddr32].exitcs; \
+		ip = addrcache[tempaddr32].exitip; \
+		mode = addrcache[tempaddr32].mode; \
+		reg = addrcache[tempaddr32].reg; \
+		rm = addrcache[tempaddr32].rm; \
+		if ((!segoverride) && addrcache[tempaddr32].forcess) useseg = segregs[regss]; \
+	} else { \
+		uncached_access_count++; \
+		addrbyte = getmem8(segregs[regcs], ip); \
+		StepIP(1); \
+		mode = addrbyte >> 6; \
+		reg = (addrbyte >> 3) & 7; \
+		rm = addrbyte & 7; \
+		addrdatalen = 0; \
+		addrcache[tempaddr32].forcess = 0; \
+		switch(mode) \
+		{ \
+		case 0: \
+		if(rm == 6) { \
+		disp16 = getmem16(segregs[regcs], ip); \
+		addrdatalen = 2; \
+		StepIP(2); \
+		} \
+		if (((rm == 2) || (rm == 3))) { \
+		if (!segoverride) useseg = segregs[regss]; \
+		addrcache[tempaddr32].forcess = 1; \
+		} \
+		break; \
+	\
+		case 1: \
+		disp16 = signext(getmem8(segregs[regcs], ip)); \
+		addrdatalen = 1; \
+		StepIP(1); \
+		if (((rm == 2) || (rm == 3) || (rm == 6))) { \
+		if (!segoverride) useseg = segregs[regss]; \
+		addrcache[tempaddr32].forcess = 1; \
+		} \
+		break; \
+	\
+		case 2: \
+		disp16 = getmem16(segregs[regcs], ip); \
+		addrdatalen = 2; \
+		StepIP(2); \
+		if (((rm == 2) || (rm == 3) || (rm == 6))) { \
+		if (!segoverride) useseg = segregs[regss]; \
+		addrcache[tempaddr32].forcess = 1; \
+		} \
+		break; \
+	\
+		default: \
+		disp16 = 0; \
+		} \
+		addrcache[tempaddr32].disp16 = disp16; \
+		addrcache[tempaddr32].exitcs = segregs[regcs]; \
+		addrcache[tempaddr32].exitip = ip; \
+		addrcache[tempaddr32].mode = mode; \
+		addrcache[tempaddr32].reg = reg; \
+		addrcache[tempaddr32].rm = rm; \
+		addrcache[tempaddr32].len = addrdatalen; \
+		memset(&addrcachevalid[tempaddr32], 1, addrdatalen+1); \
+	} \
+}
+#else
+#define modregrm() { \
+	addrbyte = getmem8(segregs[regcs], ip); \
+	StepIP(1); \
+	mode = addrbyte >> 6; \
+	reg = (addrbyte >> 3) & 7; \
+	rm = addrbyte & 7; \
+	switch(mode) \
+	{ \
+	case 0: \
+	if(rm == 6) { \
+	disp16 = getmem16(segregs[regcs], ip); \
+	StepIP(2); \
+	} \
+	if(((rm == 2) || (rm == 3)) && !segoverride) { \
+	useseg = segregs[regss]; \
+	} \
+	break; \
+ \
+	case 1: \
+	disp16 = signext(getmem8(segregs[regcs], ip)); \
+	StepIP(1); \
+	if(((rm == 2) || (rm == 3) || (rm == 6)) && !segoverride) { \
+	useseg = segregs[regss]; \
+	} \
+	break; \
+ \
+	case 2: \
+	disp16 = getmem16(segregs[regcs], ip); \
+	StepIP(2); \
+	if(((rm == 2) || (rm == 3) || (rm == 6)) && !segoverride) { \
+	useseg = segregs[regss]; \
+	} \
+	break; \
+ \
+	default: \
+	disp8 = 0; \
+	disp16 = 0; \
+	} \
+}
+#endif
\ No newline at end of file
diff --git a/src/fake86/mutex.h b/src/fake86/mutex.h
new file mode 100755
index 0000000..e0f665d
--- /dev/null
+++ b/src/fake86/mutex.h
@@ -0,0 +1,29 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#ifdef _WIN32
+    #include <Windows.h>
+    #include <process.h>
+    #define MutexLock(mutex) EnterCriticalSection(&mutex)
+    #define MutexUnlock(mutex) LeaveCriticalSection(&mutex)
+#else
+    #include <pthread.h>
+    #define MutexLock(mutex) pthread_mutex_lock(&mutex)
+    #define MutexUnlock(mutex) pthread_mutex_unlock(&mutex)
+#endif
diff --git a/src/fake86/netcard.c b/src/fake86/netcard.c
new file mode 100755
index 0000000..ab7d6d5
--- /dev/null
+++ b/src/fake86/netcard.c
@@ -0,0 +1,83 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* netcard.c: this is a simple custom ethernet adapter interface for Fake86.
+   it's not modeled after a real-world ethernet adapter, thus i had to create
+   own DOS packet driver for programs to make use of it. this packet driver
+   is included with this source code, in the data/ directory. the filename is
+   pd.com - inject this file into any floppy or hard disk image if needed! */
+
+#include "config.h"
+#ifdef NETWORKING_ENABLED
+#ifdef NETWORKING_OLDCARD
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include "cpu.h"
+
+extern uint8_t verbose;
+extern union _bytewordregs_ regs;
+extern uint8_t	RAM[0x100000], readonly[0x100000], ethif;
+extern uint16_t	segregs[4];
+extern void sendpkt (uint8_t *src, uint16_t len);
+
+struct netstruct {
+	uint8_t enabled;
+	uint8_t canrecv;
+	uint16_t pktlen;
+} net;
+
+void nethandler() {
+	uint32_t i;
+	if (ethif==254) return; //networking not enabled
+	switch (regs.byteregs[regah]) { //function number
+			case 0x00: //enable packet reception
+				net.enabled = 1;
+				net.canrecv = 1;
+				return;
+			case 0x01: //send packet of CX at DS:SI
+				if (verbose) {
+						printf ("Sending packet of %u bytes.\n", regs.wordregs[regcx]);
+					}
+				sendpkt (&RAM[ ( (uint32_t) segregs[regds] << 4) + (uint32_t) regs.wordregs[regsi]], regs.wordregs[regcx]);
+				return;
+			case 0x02: //return packet info (packet buffer in DS:SI, length in CX)
+				segregs[regds] = 0xD000;
+				regs.wordregs[regsi] = 0x0000;
+				regs.wordregs[regcx] = net.pktlen;
+				return;
+			case 0x03: //copy packet to final destination (given in ES:DI)
+				memcpy (&RAM[ ( (uint32_t) segregs[reges] << 4) + (uint32_t) regs.wordregs[regdi]], &RAM[0xD0000], net.pktlen);
+				return;
+			case 0x04: //disable packets
+				net.enabled = 0;
+				net.canrecv = 0;
+				return;
+			case 0x05: //DEBUG: dump packet (DS:SI) of CX bytes to stdout
+				for (i=0; i<regs.wordregs[regcx]; i++) {
+						printf ("%c", RAM[ ( (uint32_t) segregs[regds] << 4) + (uint32_t) regs.wordregs[regsi] + i]);
+					}
+				return;
+			case 0x06: //DEBUG: print milestone string
+				//print("PACKET DRIVER MILESTONE REACHED\n");
+				return;
+		}
+}
+#endif
+#endif
diff --git a/src/fake86/packet.c b/src/fake86/packet.c
new file mode 100755
index 0000000..38ce12e
--- /dev/null
+++ b/src/fake86/packet.c
@@ -0,0 +1,185 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* packet.c: functions to interface with libpcap/winpcap for ethernet emulation. */
+
+#include "config.h"
+
+#ifdef NETWORKING_ENABLED
+#define HAVE_REMOTE
+#define WPCAP
+#include <pcap.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <memory.h>
+
+#ifndef _WIN32
+#define PCAP_OPENFLAG_PROMISCUOUS 1
+#endif
+
+extern uint8_t RAM[0x100000];
+extern uint8_t verbose;
+uint8_t ethif, net_enabled = 0;
+uint8_t dopktrecv = 0;
+uint16_t rcvseg, rcvoff, hdrlen, handpkt;
+
+pcap_if_t *alldevs;
+pcap_if_t *d;
+pcap_t *adhandle;
+const u_char *pktdata;
+struct pcap_pkthdr *hdr;
+int inum;
+uint16_t curhandle = 0;
+char errbuf[PCAP_ERRBUF_SIZE];
+uint8_t maclocal[6] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x13, 0x37 };
+
+void initpcap() {
+	int i=0;
+
+	printf ("\nObtaining NIC list via libpcap...\n");
+
+	/* Retrieve the device list from the local machine */
+#if defined(_WIN32)
+	if (pcap_findalldevs_ex (PCAP_SRC_IF_STRING, NULL /* auth is not needed */, &alldevs, errbuf) == -1)
+#else
+	if (pcap_findalldevs (&alldevs, errbuf) == -1)
+#endif
+		{
+			printf ("Error in pcap_findalldevs_ex: %s\n", errbuf);
+			exit (1);
+		}
+
+	/* Print the list */
+	for (d= alldevs; d != NULL; d= d->next) {
+			i++;
+			if (ethif==255) {
+					printf ("%d. %s", i, d->name);
+					if (d->description) {
+							printf (" (%s)\n", d->description);
+						}
+					else {
+							printf (" (No description available)\n");
+						}
+				}
+		}
+
+	if (i == 0) {
+			printf ("\nNo interfaces found! Make sure WinPcap is installed.\n");
+			return;
+		}
+
+	printf ("\n");
+
+	if (ethif==255) exit (0);
+	else inum = ethif;
+	printf ("Using network interface %u.\n", ethif);
+
+
+	if (inum < 1 || inum > i) {
+			printf ("\nInterface number out of range.\n");
+			/* Free the device list */
+			pcap_freealldevs (alldevs);
+			return;
+		}
+
+	/* Jump to the selected adapter */
+	for (d=alldevs, i=0; i< inum-1 ; d=d->next, i++);
+
+	/* Open the device */
+#ifdef _WIN32
+	if ( (adhandle= pcap_open (d->name, 65536, PCAP_OPENFLAG_PROMISCUOUS, -1, NULL, errbuf) ) == NULL)
+#else
+	if ( (adhandle= pcap_open_live (d->name, 65535, 1, -1, NULL) ) == NULL)
+#endif
+		{
+			printf ("\nUnable to open the adapter. %s is not supported by WinPcap\n", d->name);
+			/* Free the device list */
+			pcap_freealldevs (alldevs);
+			return;
+		}
+
+	printf ("\nEthernet bridge on %s...\n", d->description);
+
+	/* At this point, we don't need any more the device list. Free it */
+	pcap_freealldevs (alldevs);
+	net_enabled = 1;
+}
+
+void setmac() {
+	memcpy (&RAM[0xE0000], &maclocal[0], 6);
+}
+
+#ifndef NETWORKING_OLDCARD
+extern int ne2000_can_receive();
+extern void ne2000_receive (const uint8_t *buf, int size);
+
+uint8_t newrecv[5000];
+
+void dispatch() {
+	uint16_t i;
+
+	if (pcap_next_ex (adhandle, &hdr, &pktdata) <=0) return;
+	if (hdr->len==0) return;
+	if (ne2000_can_receive() ) {
+			for (i=0; i<hdr->len; i++) {
+					newrecv[i<<1] = pktdata[i];
+					newrecv[ (i<<1) +1] = 0;
+				}
+			ne2000_receive (newrecv, hdr->len);
+		}
+	return;
+}
+
+void sendpkt (uint8_t *src, uint16_t len) {
+	uint16_t i;
+	for (i=0; i<len; i++) {
+			printf ("%02X ", src[i]);
+		}
+	printf ("\n");
+	pcap_sendpacket (adhandle, src, len);
+}
+#else
+extern struct netstruct {
+	uint8_t enabled;
+	uint8_t canrecv;
+	uint16_t pktlen;
+} net;
+
+extern void doirq (uint8_t irqnum);
+
+void dispatch() {
+	if (pcap_next_ex (adhandle, &hdr, &pktdata) <=0) return;
+	if (hdr->len==0) return;
+
+	net.canrecv = 0;
+	memcpy (&RAM[0xD0000], &pktdata[0], hdr->len);
+	net.pktlen = (uint16_t) hdr->len;
+	if (verbose) {
+			printf ("Received packet of %u bytes.\n", net.pktlen);
+		}
+	doirq (6);
+	return;
+}
+
+void sendpkt (uint8_t *src, uint16_t len) {
+	pcap_sendpacket (adhandle, src, len);
+}
+#endif
+
+#endif
diff --git a/src/fake86/parsecl.c b/src/fake86/parsecl.c
new file mode 100755
index 0000000..8751920
--- /dev/null
+++ b/src/fake86/parsecl.c
@@ -0,0 +1,228 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* parsecl.c: Fake86 command line parsing for runtime options. */
+
+#include "config.h"
+#include <SDL/SDL.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "disk.h"
+
+extern struct struct_drive disk[256];
+#ifndef _WIN32
+#define strcmpi strcasecmp
+#else
+#define strcmpi _strcmpi
+#endif
+
+extern uint8_t bootdrive, ethif, verbose, cgaonly, *biosfile, usessource, noscale, nosmooth, renderbenchmark, useconsole, doaudio;
+extern uint32_t framedelay, textbase, usefullscreen, speed;
+extern int32_t usesamplerate, latency;
+uint16_t constantw = 0, constanth = 0;
+uint8_t slowsystem = 0;
+
+extern uint8_t insertdisk (uint8_t drivenum, char *filename);
+extern uint32_t loadrom (uint32_t addr32, uint8_t *filename, uint8_t failure_fatal);
+
+uint32_t hextouint(char *src) {
+	uint32_t tempuint = 0, cc;
+	uint16_t i;
+
+	for (i=0; i<strlen(src); i++) {
+		cc = src[i];
+		if (cc == 0) break;
+		if ((cc >= 'a') && (cc <= 'F')) cc = cc - 'a' + 10;
+			else if ((cc >= 'A') && (cc <= 'F')) cc =  cc - 'A' + 10;
+			else if ((cc >= '0') && (cc <= '9')) cc = cc - '0';
+			else return(0);
+		tempuint <<= 4;
+		tempuint |= cc;
+	}
+	return(tempuint);
+}
+
+void showhelp () {
+	printf ("Fake86 requires some command line parameters to run.\nValid options:\n");
+
+	printf ("  -fd0 filename    Specify a floppy disk image file to use as floppy 0.\n");
+	printf ("  -fd1 filename    Specify a floppy disk image file to use as floppy 1.\n");
+	printf ("  -hd0 filename    Specify a hard disk image file to use as hard drive 0.\n");
+	printf ("  -hd1 filename    Specify a hard disk image file to use as hard drive 1.\n");
+	printf ("  -boot #          Specify which BIOS drive ID should be the boot device in #.\n");
+	printf ("                   Examples: -boot 0 will boot from floppy 0.\n");
+	printf ("                             -boot 1 will boot from floppy 1.\n");
+	printf ("                             -boot 128 will boot from hard drive 0.\n");
+	printf ("                             -boot rom will boot to ROM BASIC if available.\n");
+	printf ("                   Default boot device is hard drive 0, if it exists.\n");
+	printf ("                   Otherwise, the default is floppy 0.\n");
+	printf ("  -bios filename   Specify alternate BIOS ROM image to use.\n");
+#ifdef NETWORKING_ENABLED
+#ifdef _WIN32
+	printf ("  -net #           Enable ethernet emulation via winpcap, where # is the\n");
+#else
+	printf ("  -net #           Enable ethernet emulation via libpcap, where # is the\n");
+#endif
+	printf ("                   numeric ID of your host's network interface to bridge.\n");
+	printf ("                   To get a list of possible interfaces, use -net list\n");
+#endif
+	printf ("  -nosound         Disable audio emulation and output.\n");
+	printf ("  -fullscreen      Start Fake86 in fullscreen mode.\n");
+	printf ("  -verbose         Verbose mode. Operation details will be written to stdout.\n");
+	printf ("  -delay           Specify how many milliseconds the render thread should idle\n");
+	printf ("                   between drawing each frame. Default is 20 ms. (~50 FPS)\n");
+	printf ("  -slowsys         If your machine is very slow and you have audio dropouts,\n");
+	printf ("                   use this option to sacrifice audio quality to compensate.\n");
+	printf ("                   If you still have dropouts, then also decrease sample rate\n");
+	printf ("                   and/or increase latency.\n");
+	printf ("  -resw # -resh #  Force a constant window size in pixels.\n");
+	printf ("  -smooth          Apply smoothing to screen rendering.\n");
+	printf ("  -noscale         Disable 2x scaling of low resolution video modes.\n");
+	printf ("  -ssource         Enable Disney Sound Source emulation on LPT1.\n");
+	printf ("  -latency #       Change audio buffering and output latency. (default: 100 ms)\n");
+	printf ("  -samprate #      Change audio emulation sample rate. (default: 48000 Hz)\n");
+	printf ("  -console         Enable console on stdio during emulation.\n");
+	printf ("  -oprom addr rom  Inject a custom option ROM binary at an address in hex.\n");
+	printf ("                   Example: -oprom F4000 monitor.bin\n");
+	printf ("                            This loads the data from monitor.bin at 0xF4000.\n");
+
+	printf ("\nThis program is free software; you can redistribute it and/or\n");
+	printf ("modify it under the terms of the GNU General Public License\n");
+	printf ("as published by the Free Software Foundation; either version 2\n");
+	printf ("of the License, or (at your option) any later version.\n\n");
+
+	printf ("This program is distributed in the hope that it will be useful,\n");
+	printf ("but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
+	printf ("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
+	printf ("GNU General Public License for more details.\n");
+
+	exit (0);
+}
+
+void parsecl (int argc, char *argv[]) {
+	uint32_t tempuint;
+	int i, abort = 0;
+
+	if (argc<2) {
+			printf ("Invoke Fake86 with the parameter -h for help and usage information.\n");
+#ifndef _WIN32
+			exit (0);
+#endif
+		}
+
+	bootdrive = 254;
+	textbase = 0xB8000;
+	ethif = 254;
+	usefullscreen = 0;
+	biosfile = PATH_DATAFILES "pcxtbios.bin";
+	for (i=1; i<argc; i++) {
+            if (strcmpi (argv[i], "-h") ==0) showhelp ();
+            else if (strcmpi (argv[i], "-?") ==0) showhelp ();
+            else if (strcmpi (argv[i], "-help") ==0) showhelp ();
+			else if (strcmpi (argv[i], "-fd0") ==0) {
+					i++;
+					if (insertdisk (0, argv[i]) ) {
+							printf ("ERROR: Unable to open image file %s\n", argv[i]);
+						}
+				}
+			else if (strcmpi (argv[i], "-fd1") ==0) {
+					i++;
+					if (insertdisk (1, argv[i]) ) {
+							printf ("ERROR: Unable to open image file %s\n", argv[i]);
+						}
+				}
+			else if (strcmpi (argv[i], "-hd0") ==0) {
+					i++;
+					if (insertdisk (0x80, argv[i]) ) {
+							printf ("ERROR: Unable to open image file %s\n", argv[i]);
+						}
+				}
+			else if (strcmpi (argv[i], "-hd1") ==0) {
+					i++;
+					if (insertdisk (0x81, argv[i]) ) {
+							printf ("ERROR: Unable to open image file %s\n", argv[i]);
+						}
+				}
+			else if (strcmpi (argv[i], "-net") ==0) {
+					i++;
+					if (strcmpi (argv[i], "list") ==0) ethif = 255;
+					else ethif = atoi (argv[i]);
+				}
+			else if (strcmpi (argv[i], "-boot") ==0) {
+					i++;
+					if (strcmpi (argv[i], "rom") ==0) bootdrive = 255;
+					else bootdrive = atoi (argv[i]);
+				}
+			else if (strcmpi (argv[i], "-ssource") ==0) {
+					i++;
+					usessource = 1;
+				}
+			else if (strcmpi (argv[i], "-latency") ==0) {
+					i++;
+					latency = atol (argv[i]);
+				}
+			else if (strcmpi (argv[i], "-samprate") ==0) {
+					i++;
+					usesamplerate = atol (argv[i]);
+				}
+			else if (strcmpi (argv[i], "-bios") ==0) {
+					i++;
+					biosfile = argv[i];
+				}
+			else if (strcmpi (argv[i], "-resw") ==0) {
+					i++;
+					constantw = (uint16_t) atoi (argv[i]);
+				}
+			else if (strcmpi (argv[i], "-resh") ==0) {
+					i++;
+					constanth = (uint16_t) atoi (argv[i]);
+				}
+			else if (strcmpi (argv[i], "-speed") ==0) {
+					i++;
+					speed= (uint32_t) atol (argv[i]);
+				}
+			else if (strcmpi (argv[i], "-noscale") ==0) noscale = 1;
+			else if (strcmpi (argv[i], "-verbose") ==0) verbose = 1;
+			else if (strcmpi (argv[i], "-smooth") ==0) nosmooth = 0;
+			else if (strcmpi (argv[i], "-fps") ==0) renderbenchmark = 1;
+			else if (strcmpi (argv[i], "-nosound") ==0) doaudio = 0;
+			else if (strcmpi (argv[i], "-fullscreen") ==0) usefullscreen = SDL_FULLSCREEN;
+			else if (strcmpi (argv[i], "-delay") ==0) framedelay = atol (argv[++i]);
+			else if (strcmpi (argv[i], "-console") ==0) useconsole = 1;
+			else if (strcmpi (argv[i], "-slowsys") ==0) slowsystem = 1;
+			else if (strcmpi (argv[i], "-oprom") ==0) {
+					i++;
+					tempuint = hextouint (argv[i++]);
+					loadrom (tempuint, argv[i], 0);
+				}
+			else {
+					printf ("Unrecognized parameter: %s\n", argv[i]);
+					exit (1);
+				}
+		}
+
+	if (bootdrive==254) {
+			if (disk[0x80].inserted) bootdrive = 0x80;
+				else if (disk[0x00].inserted) bootdrive = 0;
+				else bootdrive = 0xFF; //ROM BASIC fallback
+		}
+}
+
+
diff --git a/src/fake86/ports.c b/src/fake86/ports.c
new file mode 100755
index 0000000..88f047a
--- /dev/null
+++ b/src/fake86/ports.c
@@ -0,0 +1,119 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* ports.c: functions to handle port I/O from the CPU module, as well
+   as functions for emulated hardware components to register their
+   read/write callback functions across the port address range. */
+
+#include <stdint.h>
+#include <stdio.h>
+#include "cpu.h"
+
+extern uint8_t portram[0x10000];
+extern uint8_t speakerenabled;
+extern uint8_t keyboardwaitack;
+
+void (*do_callback_write) (uint16_t portnum, uint8_t value) = NULL;
+uint8_t (*do_callback_read) (uint16_t portnum) = NULL;
+void (*do_callback_write16) (uint16_t portnum, uint16_t value) = NULL;
+uint16_t (*do_callback_read16) (uint16_t portnum) = NULL;
+void * (port_write_callback[0x10000]);
+void * (port_read_callback[0x10000]);
+void * (port_write_callback16[0x10000]);
+void * (port_read_callback16[0x10000]);
+
+extern uint8_t verbose;
+void portout (uint16_t portnum, uint8_t value) {
+	portram[portnum] = value;
+	//if (verbose) printf("portout(0x%X, 0x%02X);\n", portnum, value);
+	switch (portnum) {
+			case 0x61:
+				if ( (value & 3) == 3) speakerenabled = 1;
+				else speakerenabled = 0;
+				return;
+		}
+	do_callback_write = (void (*) (uint16_t portnum, uint8_t value) ) port_write_callback[portnum];
+	if (do_callback_write != (void *) 0) (*do_callback_write) (portnum, value);
+}
+
+uint8_t portin (uint16_t portnum) {
+	//if (verbose) printf("portin(0x%X);\n", portnum);
+	switch (portnum) {
+			case 0x62:
+				return (0x00);
+			case 0x60:
+			case 0x61:
+			case 0x63:
+			case 0x64:
+				return (portram[portnum]);
+		}
+	do_callback_read = (uint8_t (*) (uint16_t portnum) ) port_read_callback[portnum];
+	if (do_callback_read != (void *) 0) return ( (*do_callback_read) (portnum) );
+	return (0xFF);
+}
+
+void portout16 (uint16_t portnum, uint16_t value) {
+	do_callback_write16 = (void (*) (uint16_t portnum, uint16_t value) ) port_write_callback16[portnum];
+	if (do_callback_write16 != (void *) 0) {
+			(*do_callback_write16) (portnum, value);
+			return;
+		}
+
+	portout (portnum, (uint8_t) value);
+	portout (portnum + 1, (uint8_t) (value >> 8) );
+}
+
+uint16_t portin16 (uint16_t portnum) {
+	uint16_t ret;
+
+	do_callback_read16 = (uint16_t (*) (uint16_t portnum) ) port_read_callback16[portnum];
+	if (do_callback_read16 != (void *) 0) return ( (*do_callback_read16) (portnum) );
+
+	ret = (uint16_t) portin (portnum);
+	ret |= (uint16_t) portin (portnum+1) << 8;
+	return (ret);
+}
+
+void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback) {
+	uint16_t i;
+	for (i=startport; i<=endport; i++) {
+			port_write_callback[i] = callback;
+		}
+}
+
+void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback) {
+	uint16_t i;
+	for (i=startport; i<=endport; i++) {
+			port_read_callback[i] = callback;
+		}
+}
+
+void set_port_write_redirector_16 (uint16_t startport, uint16_t endport, void *callback) {
+	uint16_t i;
+	for (i=startport; i<=endport; i++) {
+			port_write_callback16[i] = callback;
+		}
+}
+
+void set_port_read_redirector_16 (uint16_t startport, uint16_t endport, void *callback) {
+	uint16_t i;
+	for (i=startport; i<=endport; i++) {
+			port_read_callback16[i] = callback;
+		}
+}
diff --git a/src/fake86/render.c b/src/fake86/render.c
new file mode 100755
index 0000000..4f51639
--- /dev/null
+++ b/src/fake86/render.c
@@ -0,0 +1,570 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* render.c: functions for SDL initialization, as well as video scaling/rendering.
+   it is a bit messy. i plan to rework much of this in the future. i am also
+   going to add hardware accelerated scaling soon. */
+
+#include <SDL/SDL.h>
+#include <stdint.h>
+#include <stdio.h>
+#include "mutex.h"
+
+#ifdef _WIN32
+CRITICAL_SECTION screenmutex;
+#else
+pthread_t vidthread;
+pthread_mutex_t screenmutex = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
+SDL_Surface *screen = NULL;
+uint32_t *scalemap = NULL;
+uint8_t regenscalemap = 1;
+
+extern uint8_t RAM[0x100000], portram[0x10000];
+extern uint8_t VRAM[262144], vidmode, cgabg, blankattr, vidgfxmode, vidcolor, running;
+extern uint16_t cursx, cursy, cols, rows, vgapage, cursorposition, cursorvisible;
+extern uint8_t updatedscreen, clocksafe, port3da, port6, portout16;
+extern uint16_t VGA_SC[0x100], VGA_CRTC[0x100], VGA_ATTR[0x100], VGA_GC[0x100];
+extern uint32_t videobase, textbase, x, y;
+extern uint8_t fontcga[32768];
+extern uint32_t palettecga[16], palettevga[256];
+extern uint32_t usefullscreen, usegrabmode;
+
+uint64_t totalframes = 0;
+uint32_t framedelay = 20;
+uint8_t scrmodechange = 0, noscale = 0, nosmooth = 1, renderbenchmark = 0, doaudio = 1;
+char windowtitle[128];
+
+void initcga();
+#ifdef _WIN32
+void VideoThread (void *dummy);
+#else
+void *VideoThread (void *dummy);
+#endif
+
+void setwindowtitle (uint8_t *extra) {
+	char temptext[128];
+	sprintf (temptext, "%s%s", windowtitle, extra);
+	SDL_WM_SetCaption ( (const char *) temptext, NULL);
+}
+
+uint8_t initscreen (uint8_t *ver) {
+	if (doaudio) {
+			if (SDL_Init (SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER) ) return (0);
+		}
+	else {
+			if (SDL_Init (SDL_INIT_VIDEO | SDL_INIT_TIMER) ) return (0);
+		}
+	screen = SDL_SetVideoMode (640, 400, 32, SDL_HWSURFACE);
+	if (screen == NULL) return (0);
+	sprintf (windowtitle, "%s", ver);
+	setwindowtitle ("");
+	initcga();
+#ifdef _WIN32
+	InitializeCriticalSection (&screenmutex);
+	_beginthread (VideoThread, 0, NULL);
+#else
+	pthread_create (&vidthread, NULL, (void *) VideoThread, NULL);
+#endif
+
+	return (1);
+}
+
+uint32_t prestretch[1024][1024];
+uint32_t nw, nh; //native width and height, pre-stretching (i.e. 320x200 for mode 13h)
+void createscalemap() {
+	uint32_t srcx, srcy, dstx, dsty, scalemapptr;
+	double xscale, yscale;
+
+	xscale = (double) nw / (double) screen->w;
+	yscale = (double) nh / (double) screen->h;
+	if (scalemap != NULL) free(scalemap);
+	scalemap = (void *)malloc( ((uint32_t)screen->w + 1) * (uint32_t)screen->h * 4);
+	if (scalemap == NULL) {
+			printf("\nFATAL: Unable to allocate memory for scalemap!\n");
+			exit(1);
+		}
+	scalemapptr = 0;
+	for (dsty=0; dsty<(uint32_t)screen->h; dsty++) {
+			srcy = (uint32_t) ( (double) dsty * yscale);
+			scalemap[scalemapptr++] = srcy;
+			for (dstx=0; dstx<(uint32_t)screen->w; dstx++) {
+					srcx = (uint32_t) ( (double) dstx * xscale);
+					scalemap[scalemapptr++] = srcx;
+				}
+		}
+
+	regenscalemap = 0;
+}
+
+extern uint16_t oldw, oldh, constantw, constanth;
+void draw();
+extern void handleinput();
+#ifdef _WIN32
+void VideoThread (void *dummy) {
+#else
+void *VideoThread (void *dummy) {
+#endif
+	uint32_t cursorprevtick, cursorcurtick, delaycalc;
+	cursorprevtick = SDL_GetTicks();
+	cursorvisible = 0;
+
+	while (running) {
+			cursorcurtick = SDL_GetTicks();
+			if ( (cursorcurtick - cursorprevtick) >= 250) {
+					updatedscreen = 1;
+					cursorvisible = ~cursorvisible & 1;
+					cursorprevtick = cursorcurtick;
+				}
+
+			if (updatedscreen || renderbenchmark) {
+					updatedscreen = 0;
+					if (screen != NULL) {
+							MutexLock (screenmutex);
+							if (regenscalemap) createscalemap();
+							draw();
+							MutexUnlock (screenmutex);
+						}
+					totalframes++;
+				}
+			if (!renderbenchmark) {
+					delaycalc = framedelay - (SDL_GetTicks() - cursorcurtick);
+					if (delaycalc > framedelay) delaycalc = framedelay;
+					SDL_Delay (delaycalc);
+				}
+		}
+}
+
+#ifdef _WIN32
+void ShowMenu();
+void HideMenu();
+#endif
+
+void doscrmodechange() {
+	MutexLock (screenmutex);
+	if (scrmodechange) {
+			if (screen != NULL) SDL_FreeSurface (screen);
+#ifdef _WIN32
+			if (usefullscreen) HideMenu(); else ShowMenu();
+#endif
+			if (constantw && constanth) screen = SDL_SetVideoMode (constantw, constanth, 32, SDL_HWSURFACE | usefullscreen);
+			else if (noscale) screen = SDL_SetVideoMode (nw, nh, 32, SDL_HWSURFACE | usefullscreen);
+			else {
+					if ( (nw >= 640) || (nh >= 400) ) screen = SDL_SetVideoMode (nw, nh, 32, SDL_HWSURFACE | usefullscreen);
+					else screen = SDL_SetVideoMode (640, 400, 32, SDL_HWSURFACE | usefullscreen);
+				}
+			if (usefullscreen) SDL_WM_GrabInput (SDL_GRAB_ON); //always have mouse grab turned on for full screen mode
+			else SDL_WM_GrabInput (usegrabmode);
+			SDL_ShowCursor (SDL_DISABLE);
+			if (!usefullscreen) {
+					if (usegrabmode == SDL_GRAB_ON) setwindowtitle (" (press Ctrl + Alt to release mouse)");
+					else setwindowtitle ("");
+				}
+			regenscalemap = 1;
+			createscalemap();
+		}
+	MutexUnlock (screenmutex);
+	scrmodechange = 0;
+}
+
+void stretchblit (SDL_Surface *target) {
+	uint32_t srcx, srcy, dstx, dsty, lastx, lasty, r, g, b;
+	uint32_t consecutivex, consecutivey = 0, limitx, limity, scalemapptr;
+	uint32_t ofs;
+	uint8_t *pixelrgb;
+
+	limitx = (uint32_t)((double) nw / (double) target->w);
+	limity = (uint32_t)((double) nh / (double) target->h);
+
+	if (SDL_MUSTLOCK (target) )
+		if (SDL_LockSurface (target) < 0)
+			return;
+
+	lasty = 0;
+	scalemapptr = 0;
+	for (dsty=0; dsty<(uint32_t)target->h; dsty++) {
+			srcy = scalemap[scalemapptr++];
+			ofs = dsty*target->w;
+			consecutivex = 0;
+			lastx = 0;
+			if (srcy == lasty) consecutivey++;
+			else consecutivey = 0;
+			for (dstx=0; dstx<(uint32_t)target->w; dstx++) {
+					srcx = scalemap[scalemapptr++];
+					pixelrgb = (uint8_t *) &prestretch[srcy][srcx];
+					r = pixelrgb[0];
+					g = pixelrgb[1];
+					b = pixelrgb[2];
+					if (srcx == lastx) consecutivex++;
+					else consecutivex = 0;
+					if ( (consecutivex > limitx) && (consecutivey > limity) ) {
+							pixelrgb = (uint8_t *) &prestretch[srcy][srcx+1];
+							r += pixelrgb[0];
+							g += pixelrgb[1];
+							b += pixelrgb[2];
+							pixelrgb = (uint8_t *) &prestretch[srcy+1][srcx];
+							r += pixelrgb[0];
+							g += pixelrgb[1];
+							b += pixelrgb[2];
+							pixelrgb = (uint8_t *) &prestretch[srcy+1][srcx+1];
+							r += pixelrgb[0];
+							g += pixelrgb[1];
+							b += pixelrgb[2];
+							r = r >> 2;
+							g = g >> 2;
+							b = b >> 2;
+							//r = 255; g = 0; b = 0;
+						}
+					else if (consecutivex > limitx) {
+							pixelrgb = (uint8_t *) &prestretch[srcy][srcx+1];
+							r += pixelrgb[0];
+							r = r >> 1;
+							g += pixelrgb[1];
+							g = g >> 1;
+							b += pixelrgb[2];
+							b = b >> 1;
+							//r = 0; g = 255; b = 0;
+						}
+					else if (consecutivey > limity) {
+							pixelrgb = (uint8_t *) &prestretch[srcy+1][srcx];
+							r += pixelrgb[0];
+							r = r >> 1;
+							g += pixelrgb[1];
+							g = g >> 1;
+							b += pixelrgb[2];
+							b = b >> 1;
+							//r = 0; g = 0; b = 255;
+						}
+					( (uint32_t *) target->pixels) [ofs++] = SDL_MapRGB (target->format, (uint8_t) r, (uint8_t) g, (uint8_t) b);
+					lastx = srcx;
+				}
+			lasty = srcy;
+		}
+
+	if (SDL_MUSTLOCK (target) )
+		SDL_UnlockSurface (target);
+	SDL_UpdateRect (target, 0, 0, target->w, target->h);
+}
+
+void roughblit (SDL_Surface *target) {
+	uint32_t srcx, srcy, dstx, dsty, scalemapptr;
+	int32_t ofs;
+	uint8_t *pixelrgb;
+
+	if (SDL_MUSTLOCK (target) )
+		if (SDL_LockSurface (target) < 0)
+			return;
+
+	scalemapptr = 0;
+	for (dsty=0; dsty<(uint32_t)target->h; dsty++) {
+			srcy = scalemap[scalemapptr++];
+			ofs = dsty*target->w;
+			for (dstx=0; dstx<(uint32_t)target->w; dstx++) {
+					srcx = scalemap[scalemapptr++];
+					pixelrgb = (uint8_t *) &prestretch[srcy][srcx];
+					( (uint32_t *) target->pixels) [ofs++] = SDL_MapRGB (target->format, pixelrgb[0], pixelrgb[1], pixelrgb[2]);
+				}
+		}
+
+	if (SDL_MUSTLOCK (target) )
+		SDL_UnlockSurface (target);
+	SDL_UpdateRect (target, 0, 0, target->w, target->h);
+}
+
+/* NOTE: doubleblit is only used when smoothing is not enabled, and the SDL window size
+         is exactly double of native resolution for the current video mode. we can take
+         advantage of the fact that every pixel is simply doubled both horizontally and
+         vertically. this way, we do not need to waste mountains of CPU time doing
+         floating point multiplication for each and every on-screen pixel. it makes the
+         difference between games being smooth and playable, and being jerky on my old
+         400 MHz PowerPC G3 iMac.
+*/
+void doubleblit (SDL_Surface *target) {
+	uint32_t srcx, srcy, dstx, dsty, curcolor;
+	int32_t ofs, startofs;
+	uint8_t *pixelrgb;
+
+	if (SDL_MUSTLOCK (target) )
+		if (SDL_LockSurface (target) < 0)
+			return;
+
+	for (dsty=0; dsty<(uint32_t)target->h; dsty += 2) {
+			srcy = (uint32_t) (dsty >> 1);
+			startofs = ofs = dsty*target->w;
+			for (dstx=0; dstx<(uint32_t)target->w; dstx += 2) {
+					srcx = (uint32_t) (dstx >> 1);
+					pixelrgb = (uint8_t *) &prestretch[srcy][srcx];
+					curcolor = SDL_MapRGB (target->format, pixelrgb[0], pixelrgb[1], pixelrgb[2]);
+					( (uint32_t *) target->pixels) [ofs+target->w] = curcolor;
+					( (uint32_t *) target->pixels) [ofs++] = curcolor;
+					( (uint32_t *) target->pixels) [ofs+target->w] = curcolor;
+					( (uint32_t *) target->pixels) [ofs++] = curcolor;
+				}
+		}
+
+	if (SDL_MUSTLOCK (target) )
+		SDL_UnlockSurface (target);
+	SDL_UpdateRect (target, 0, 0, target->w, target->h);
+}
+
+extern uint16_t vtotal;
+void draw () {
+	uint32_t planemode, vgapage, color, chary, charx, vidptr, divx, divy, curchar, curpixel, usepal, intensity, blockw, curheight, x1, y1;
+	switch (vidmode) {
+			case 0:
+			case 1:
+			case 2: //text modes
+			case 3:
+			case 7:
+			case 0x82:
+				nw = 640;
+				nh = 400;
+				vgapage = ( (uint32_t) VGA_CRTC[0xC]<<8) + (uint32_t) VGA_CRTC[0xD];
+				for (y=0; y<400; y++)
+					for (x=0; x<640; x++) {
+							if (cols==80) {
+									charx = x/8;
+									divx = 1;
+								}
+							else {
+									charx = x/16;
+									divx = 2;
+								}
+							if ( (portram[0x3D8]==9) && (portram[0x3D4]==9) ) {
+									chary = y/4;
+									vidptr = vgapage + videobase + chary*cols*2 + charx*2;
+									curchar = RAM[vidptr];
+									color = fontcga[curchar*128 + (y%4) *8 + ( (x/divx) %8) ];
+								}
+							else {
+									chary = y/16;
+									vidptr = videobase + chary*cols*2 + charx*2;
+									curchar = RAM[vidptr];
+									color = fontcga[curchar*128 + (y%16) *8 + ( (x/divx) %8) ];
+								}
+							if (vidcolor) {
+									/*if (!color) if (portram[0x3D8]&128) color = palettecga[ (RAM[vidptr+1]/16) &7];
+										else*/ if (!color) color = palettecga[RAM[vidptr+1]/16]; //high intensity background
+									else color = palettecga[RAM[vidptr+1]&15];
+								}
+							else {
+									if ( (RAM[vidptr+1] & 0x70) ) {
+											if (!color) color = palettecga[7];
+											else color = palettecga[0];
+										}
+									else {
+											if (!color) color = palettecga[0];
+											else color = palettecga[7];
+										}
+								}
+							prestretch[y][x] = color;
+						}
+				break;
+			case 4:
+			case 5:
+				nw = 320;
+				nh = 200;
+				usepal = (portram[0x3D9]>>5) & 1;
+				intensity = ( (portram[0x3D9]>>4) & 1) << 3;
+				for (y=0; y<200; y++) {
+						for (x=0; x<320; x++) {
+								charx = x;
+								chary = y;
+								vidptr = videobase + ( (chary>>1) * 80) + ( (chary & 1) * 8192) + (charx >> 2);
+								curpixel = RAM[vidptr];
+								switch (charx & 3) {
+										case 3:
+											curpixel = curpixel & 3;
+											break;
+										case 2:
+											curpixel = (curpixel>>2) & 3;
+											break;
+										case 1:
+											curpixel = (curpixel>>4) & 3;
+											break;
+										case 0:
+											curpixel = (curpixel>>6) & 3;
+											break;
+									}
+								if (vidmode==4) {
+										curpixel = curpixel * 2 + usepal + intensity;
+										if (curpixel == (usepal + intensity) )  curpixel = cgabg;
+										color = palettecga[curpixel];
+										prestretch[y][x] = color;
+									}
+								else {
+										curpixel = curpixel * 63;
+										color = palettecga[curpixel];
+										prestretch[y][x] = color;
+									}
+							}
+					}
+				break;
+			case 6:
+				nw = 640;
+				nh = 200;
+				for (y=0; y<400; y+=2) {
+						for (x=0; x<640; x++) {
+								charx = x;
+								chary = y >> 1;
+								vidptr = videobase + ( (chary>>1) * 80) + ( (chary&1) * 8192) + (charx>>3);
+								curpixel = (RAM[vidptr]>> (7- (charx&7) ) ) &1;
+								color = palettecga[curpixel*15];
+								prestretch[y][x] = color;
+								prestretch[y+1][x] = color;
+							}
+					}
+				break;
+			case 127:
+				nw = 720;
+				nh = 348;
+				for (y=0; y<348; y++) {
+						for (x=0; x<720; x++) {
+								charx = x;
+								chary = y>>1;
+								vidptr = videobase + ( (y & 3) << 13) + (y >> 2) *90 + (x >> 3);
+								curpixel = (RAM[vidptr]>> (7- (charx&7) ) ) &1;
+#ifdef __BIG_ENDIAN__
+								if (curpixel) color = 0xFFFFFF00;
+#else
+								if (curpixel) color = 0x00FFFFFF;
+#endif
+								else color = 0x00000000;
+								prestretch[y][x] = color;
+							}
+					}
+				break;
+			case 0x8: //160x200 16-color (PCjr)
+				nw = 640; //fix this
+				nh = 400; //part later
+				for (y=0; y<400; y++)
+					for (x=0; x<640; x++) {
+							vidptr = 0xB8000 + (y>>2) *80 + (x>>3) + ( (y>>1) &1) *8192;
+							if ( ( (x>>1) &1) ==0) color = palettecga[RAM[vidptr] >> 4];
+							else color = palettecga[RAM[vidptr] & 15];
+							prestretch[y][x] = color;
+						}
+				break;
+			case 0x9: //320x200 16-color (Tandy/PCjr)
+				nw = 640; //fix this
+				nh = 400; //part later
+				for (y=0; y<400; y++)
+					for (x=0; x<640; x++) {
+							vidptr = 0xB8000 + (y>>3) *160 + (x>>2) + ( (y>>1) &3) *8192;
+							if ( ( (x>>1) &1) ==0) color = palettecga[RAM[vidptr] >> 4];
+							else color = palettecga[RAM[vidptr] & 15];
+							prestretch[y][x] = color;
+						}
+				break;
+			case 0xD:
+			case 0xE:
+				nw = 640; //fix this
+				nh = 400; //part later
+				for (y=0; y<400; y++)
+					for (x=0; x<640; x++) {
+							divx = x>>1;
+							divy = y>>1;
+							vidptr = divy*40 + (divx>>3);
+							x1 = 7 - (divx & 7);
+							color = (VRAM[vidptr] >> x1) & 1;
+							color += ( ( (VRAM[0x10000 + vidptr] >> x1) & 1) << 1);
+							color += ( ( (VRAM[0x20000 + vidptr] >> x1) & 1) << 2);
+							color += ( ( (VRAM[0x30000 + vidptr] >> x1) & 1) << 3);
+							color = palettevga[color];
+							prestretch[y][x] = color;
+						}
+				break;
+			case 0x10:
+				nw = 640;
+				nh = 350;
+				for (y=0; y<350; y++)
+					for (x=0; x<640; x++) {
+							vidptr = y*80 + (x>>3);
+							x1 = 7 - (x & 7);
+							color = (VRAM[vidptr] >> x1) & 1;
+							color |= ( ( (VRAM[0x10000 + vidptr] >> x1) & 1) << 1);
+							color |= ( ( (VRAM[0x20000 + vidptr] >> x1) & 1) << 2);
+							color |= ( ( (VRAM[0x30000 + vidptr] >> x1) & 1) << 3);
+							color = palettevga[color];
+							prestretch[y][x] = color;
+						}
+				break;
+			case 0x12:
+				nw = 640;
+				nh = 480;
+				vgapage = ( (uint32_t) VGA_CRTC[0xC]<<8) + (uint32_t) VGA_CRTC[0xD];
+				for (y=0; y<nh; y++)
+					for (x=0; x<nw; x++) {
+							vidptr = y*80 + (x/8);
+							color  = (VRAM[vidptr] >> (~x & 7) ) & 1;
+							color |= ( (VRAM[vidptr+0x10000] >> (~x & 7) ) & 1) << 1;
+							color |= ( (VRAM[vidptr+0x20000] >> (~x & 7) ) & 1) << 2;
+							color |= ( (VRAM[vidptr+0x30000] >> (~x & 7) ) & 1) << 3;
+							prestretch[y][x] = palettevga[color];
+						}
+				break;
+			case 0x13:
+				if (vtotal == 11) { //ugly hack to show Flashback at the proper resolution
+						nw = 256;
+						nh = 224;
+					}
+				else {
+						nw = 320;
+						nh = 200;
+					}
+				if (VGA_SC[4] & 6) planemode = 1;
+				else planemode = 0;
+				//vgapage = ( (uint32_t) VGA_CRTC[0xC]<<8) + (uint32_t) VGA_CRTC[0xD];
+				vgapage = (( (uint32_t) VGA_CRTC[0xC]<<8) + (uint32_t) VGA_CRTC[0xD]) << 2;
+				for (y=0; y<nh; y++)
+					for (x=0; x<nw; x++) {
+							if (!planemode) color = palettevga[RAM[videobase + ((vgapage + y*nw + x) & 0xFFFF) ]];
+							//if (!planemode) color = palettevga[RAM[videobase + y*nw + x]];
+							else {
+									vidptr = y*nw + x;
+									vidptr = vidptr/4 + (x & 3) *0x10000;
+									vidptr = vidptr + vgapage - (VGA_ATTR[0x13] & 15);
+									color = palettevga[VRAM[vidptr]];
+								}
+							prestretch[y][x] = color;
+						}
+		}
+
+	if (vidgfxmode==0) {
+			if (cursorvisible) {
+					curheight = 2;
+					if (cols==80) blockw = 8;
+					else blockw = 16;
+					x1 = cursx * blockw;
+					y1 = cursy * 8 + 8 - curheight;
+					for (y=y1*2; y<=y1*2+curheight-1; y++)
+						for (x=x1; x<=x1+blockw-1; x++) {
+								color = palettecga[RAM[videobase+cursy*cols*2+cursx*2+1]&15];
+								prestretch[y&1023][x&1023] = color;
+							}
+				}
+		}
+	if (nosmooth) {
+			if ( ((nw << 1) == screen->w) && ((nh << 1) == screen->h) ) doubleblit (screen);
+			else roughblit (screen);
+		}
+	else stretchblit (screen);
+}
+
diff --git a/src/fake86/sermouse.c b/src/fake86/sermouse.c
new file mode 100755
index 0000000..98e25ab
--- /dev/null
+++ b/src/fake86/sermouse.c
@@ -0,0 +1,97 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* sermouse.c: functions to emulate a standard Microsoft-compatible serial mouse. */
+
+#include "config.h"
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include "sermouse.h"
+
+extern void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void doirq (uint8_t irqnum);
+
+struct sermouse_s sermouse;
+
+void bufsermousedata (uint8_t value) {
+	if (sermouse.bufptr == 16) return;
+	if (sermouse.bufptr == 0 ) doirq (4);
+	sermouse.buf[sermouse.bufptr++] = value;
+}
+
+void outsermouse (uint16_t portnum, uint8_t value) {
+	uint8_t oldreg;
+	//printf("[DEBUG] Serial mouse, port %X out: %02X\n", portnum, value);
+	portnum &= 7;
+	oldreg = sermouse.reg[portnum];
+	sermouse.reg[portnum] = value;
+	switch (portnum) {
+			case 4: //modem control register
+				if ( (value & 1) != (oldreg & 1) ) { //software toggling of this register
+						sermouse.bufptr = 0; //causes the mouse to reset and fill the buffer
+						bufsermousedata ('M'); //with a bunch of ASCII 'M' characters.
+						bufsermousedata ('M'); //this is intended to be a way for
+						bufsermousedata ('M'); //drivers to verify that there is
+						bufsermousedata ('M'); //actually a mouse connected to the port.
+						bufsermousedata ('M');
+						bufsermousedata ('M');
+					}
+				break;
+		}
+}
+
+uint8_t insermouse (uint16_t portnum) {
+	uint8_t temp;
+	//printf("[DEBUG] Serial mouse, port %X in\n", portnum);
+	portnum &= 7;
+	switch (portnum) {
+			case 0: //data receive
+				temp = sermouse.buf[0];
+				memmove (sermouse.buf, &sermouse.buf[1], 15);
+				sermouse.bufptr--;
+				if (sermouse.bufptr < 0) sermouse.bufptr = 0;
+				if (sermouse.bufptr > 0) doirq (4);
+				sermouse.reg[4] = ~sermouse.reg[4] & 1;
+				return (temp);
+			case 5: //line status register (read-only)
+				if (sermouse.bufptr > 0) temp = 1;
+				else temp = 0;
+				return (0x1);
+				return (0x60 | temp);
+		}
+	return (sermouse.reg[portnum & 7]);
+}
+
+void initsermouse (uint16_t baseport, uint8_t irq) {
+	sermouse.bufptr = 0;
+	set_port_write_redirector (baseport, baseport + 7, &outsermouse);
+	set_port_read_redirector (baseport, baseport + 7, &insermouse);
+}
+
+void sermouseevent (uint8_t buttons, int8_t xrel, int8_t yrel) {
+	uint8_t highbits = 0;
+	if (xrel < 0) highbits = 3;
+	else highbits = 0;
+	if (yrel < 0) highbits |= 12;
+	bufsermousedata (0x40 | (buttons << 4) | highbits);
+	bufsermousedata (xrel & 63);
+	bufsermousedata (yrel & 63);
+}
diff --git a/src/fake86/sermouse.h b/src/fake86/sermouse.h
new file mode 100755
index 0000000..d9d71ba
--- /dev/null
+++ b/src/fake86/sermouse.h
@@ -0,0 +1,26 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include <stdint.h>
+
+struct sermouse_s {
+	uint8_t reg[8];
+	uint8_t buf[16];
+	int8_t bufptr;
+};
diff --git a/src/fake86/sndsource.c b/src/fake86/sndsource.c
new file mode 100755
index 0000000..515d1c7
--- /dev/null
+++ b/src/fake86/sndsource.c
@@ -0,0 +1,82 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* ssource.c: functions to emulate the Disney Sound Source's 16-byte FIFO buffer. */
+
+#include "config.h"
+#include <stdint.h>
+
+extern void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback);
+
+extern uint8_t portram[0x10000];
+uint8_t ssourcebuf[16], ssourceptr = 0, ssourceactive = 0;
+int16_t ssourcecursample = 0;
+
+int16_t getssourcebyte() {
+	return (ssourcecursample);
+}
+
+void tickssource() {
+	uint8_t rotatefifo;
+	if ( (ssourceptr==0) || (!ssourceactive) ) {
+			ssourcecursample = 0;
+			return;
+		}
+	ssourcecursample = ssourcebuf[0];
+	for (rotatefifo=1; rotatefifo<16; rotatefifo++)
+		ssourcebuf[rotatefifo-1] = ssourcebuf[rotatefifo];
+	ssourceptr--;
+	portram[0x379] = 0;
+}
+
+void putssourcebyte (uint8_t value) {
+	if (ssourceptr==16) return;
+	ssourcebuf[ssourceptr++] = value;
+	if (ssourceptr==16) portram[0x379] = 0x40;
+}
+
+uint8_t ssourcefull() {
+	if (ssourceptr==16) return (0x40);
+	else return (0x00);
+}
+
+void outsoundsource (uint16_t portnum, uint8_t value) {
+	static uint8_t last37a = 0;
+	switch (portnum) {
+			case 0x378:
+				putssourcebyte (value);
+				break;
+			case 0x37A:
+				if ( (value & 4) && ! (last37a & 4) ) putssourcebyte (portram[0x378]);
+				last37a = value;
+				break;
+		}
+}
+
+uint8_t insoundsource (uint16_t portnum) {
+	return (ssourcefull() );
+}
+
+void initsoundsource() {
+	set_port_write_redirector (0x378, 0x378, &outsoundsource);
+	set_port_write_redirector (0x37A, 0x37A, &outsoundsource);
+	set_port_read_redirector (0x379, 0x379, &insoundsource);
+	ssourceactive = 1;
+}
diff --git a/src/fake86/speaker.c b/src/fake86/speaker.c
new file mode 100755
index 0000000..df3e651
--- /dev/null
+++ b/src/fake86/speaker.c
@@ -0,0 +1,47 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* speaker.c: function to generate output samples for PC speaker emulation. */
+
+#include "config.h"
+#include <stdint.h>
+#include "i8253.h"
+#include "mutex.h"
+
+extern struct i8253_s i8253;
+
+extern uint64_t gensamplerate;
+uint64_t speakerfullstep, speakerhalfstep, speakercurstep = 0;
+int16_t speakerpos = 0;
+
+int16_t speakergensample() {
+	int16_t speakervalue;
+
+	speakerfullstep = (uint64_t) ( (float) gensamplerate / (float) i8253.chanfreq[2]);
+	if (speakerfullstep < 2) speakerfullstep = 2;
+	speakerhalfstep = speakerfullstep >> 1;
+	if (speakercurstep < speakerhalfstep) {
+			speakervalue = 32;
+		}
+	else {
+			speakervalue = -32;
+		}
+	speakercurstep = (speakercurstep + 1) % speakerfullstep;
+	return (speakervalue);
+}
diff --git a/src/fake86/timing.c b/src/fake86/timing.c
new file mode 100755
index 0000000..b3c4b23
--- /dev/null
+++ b/src/fake86/timing.c
@@ -0,0 +1,136 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* timing.c: critical functions to provide accurate timing for the
+   system timer interrupt, and to generate new audio output samples. */
+
+#include "config.h"
+#include <SDL/SDL.h>
+#include <stdint.h>
+#include <stdio.h>
+#ifdef _WIN32
+#include <Windows.h>
+LARGE_INTEGER queryperf;
+#else
+#include <sys/time.h>
+struct timeval tv;
+#endif
+#include "i8253.h"
+#include "blaster.h"
+
+extern struct blaster_s blaster;
+extern struct i8253_s i8253;
+extern void doirq (uint8_t irqnum);
+extern void tickaudio();
+extern void tickssource();
+extern void tickadlib();
+extern void tickBlaster();
+
+uint64_t hostfreq = 1000000, lasttick = 0, curtick = 0, tickgap, i8253tickgap, lasti8253tick, scanlinetiming, lastscanlinetick, curscanline = 0;
+uint64_t sampleticks, lastsampletick, ssourceticks, lastssourcetick, adlibticks, lastadlibtick, lastblastertick, gensamplerate;
+
+uint16_t pit0counter = 65535;
+extern uint64_t totalexec;
+extern uint32_t speed;
+extern uint8_t port3da, doaudio, slowsystem;
+
+void inittiming() {
+#ifdef _WIN32
+	QueryPerformanceFrequency (&queryperf);
+	hostfreq = queryperf.QuadPart;
+	QueryPerformanceCounter (&queryperf);
+	curtick = queryperf.QuadPart;
+#else
+	hostfreq = 1000000;
+	gettimeofday (&tv, NULL);
+	curtick = (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
+#endif
+	lasti8253tick = lastblastertick = lastadlibtick = lastssourcetick = lastsampletick = lastscanlinetick = lasttick = curtick;
+	scanlinetiming = hostfreq / 31500;
+	ssourceticks = hostfreq / 8000;
+	adlibticks = hostfreq / 48000;
+	if (doaudio) sampleticks = hostfreq / gensamplerate;
+	else sampleticks = -1;
+	i8253tickgap = hostfreq / 119318;
+}
+
+void timing() {
+	uint8_t i8253chan;
+
+#ifdef _WIN32
+	QueryPerformanceCounter (&queryperf);
+	curtick = queryperf.QuadPart;
+#else
+	gettimeofday (&tv, NULL);
+	curtick = (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
+#endif
+
+	if (curtick >= (lastscanlinetick + scanlinetiming) ) {
+			curscanline = (curscanline + 1) % 525;
+			if (curscanline > 479) port3da = 8;
+			else port3da = 0;
+			if (curscanline & 1) port3da |= 1;
+			pit0counter++;
+			lastscanlinetick = curtick;
+		}
+
+	if (i8253.active[0]) { //timer interrupt channel on i8253
+			if (curtick >= (lasttick + tickgap) ) {
+					lasttick = curtick;
+					doirq (0);
+				}
+		}
+
+	if (curtick >= (lasti8253tick + i8253tickgap) ) {
+			for (i8253chan=0; i8253chan<3; i8253chan++) {
+					if (i8253.active[i8253chan]) {
+							if (i8253.counter[i8253chan] < 10) i8253.counter[i8253chan] = i8253.chandata[i8253chan];
+							i8253.counter[i8253chan] -= 10;
+						}
+				}
+			lasti8253tick = curtick;
+		}
+
+	if (curtick >= (lastssourcetick + ssourceticks) ) {
+			tickssource();
+			lastssourcetick = curtick - (curtick - (lastssourcetick + ssourceticks) );
+		}
+
+	if (blaster.samplerate > 0) {
+			if (curtick >= (lastblastertick + blaster.sampleticks) ) {
+					tickBlaster();
+					lastblastertick = curtick - (curtick - (lastblastertick + blaster.sampleticks) );
+				}
+		}
+
+	if (curtick >= (lastsampletick + sampleticks) ) {
+			tickaudio();
+			if (slowsystem) {
+					tickaudio();
+					tickaudio();
+					tickaudio();
+				}
+			lastsampletick = curtick - (curtick - (lastsampletick + sampleticks) );
+		}
+
+	if (curtick >= (lastadlibtick + adlibticks) ) {
+			tickadlib();
+			lastadlibtick = curtick - (curtick - (lastadlibtick + adlibticks) );
+		}
+}
diff --git a/src/fake86/video.c b/src/fake86/video.c
new file mode 100755
index 0000000..95c9c61
--- /dev/null
+++ b/src/fake86/video.c
@@ -0,0 +1,841 @@
+/*
+  Fake86: A portable, open-source 8086 PC emulator.
+  Copyright (C)2010-2013 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+/* video.c: many various functions to emulate bits of the video controller.
+   a lot of this code is inefficient, and just plain ugly. i plan to rework
+   large sections of it soon. */
+
+#include <SDL/SDL.h>
+#include <stdint.h>
+#include <stdio.h>
+#include "mutex.h"
+#include "cpu.h"
+
+extern void set_port_write_redirector (uint16_t startport, uint16_t endport, void *callback);
+extern void set_port_read_redirector (uint16_t startport, uint16_t endport, void *callback);
+
+extern SDL_Surface *screen;
+extern uint8_t verbose;
+extern union _bytewordregs_ regs;
+extern uint8_t RAM[0x100000], readonly[0x100000];
+extern uint8_t portram[0x10000];
+extern uint16_t segregs[4];
+
+extern uint8_t read86 (uint32_t addr32);
+extern uint8_t write86 (uint32_t addr32, uint8_t value);
+extern uint8_t scrmodechange;
+
+uint8_t VRAM[262144], vidmode, cgabg, blankattr, vidgfxmode, vidcolor;
+uint16_t cursx, cursy, cols = 80, rows = 25, vgapage, cursorposition, cursorvisible;
+uint8_t updatedscreen, clocksafe, port3da, port6, portout16;
+uint16_t VGA_SC[0x100], VGA_CRTC[0x100], VGA_ATTR[0x100], VGA_GC[0x100];
+uint32_t videobase= 0xB8000, textbase = 0xB8000, x, y;
+uint8_t fontcga[32768];
+uint32_t palettecga[16], palettevga[256];
+uint32_t usefullscreen = 0, usegrabmode = SDL_GRAB_OFF;
+
+uint8_t latchRGB = 0, latchPal = 0, VGA_latch[4], stateDAC = 0;
+uint8_t latchReadRGB = 0, latchReadPal = 0;
+uint32_t tempRGB;
+uint16_t oldw, oldh; //used when restoring screen mode
+
+uint32_t rgb(uint32_t r, uint32_t g, uint32_t b) {
+#ifdef __BIG_ENDIAN__
+	return ( (r<<24) | (g<<16) | (b<<8) );
+#else
+	return (r | (g<<8) | (b<<16) );
+#endif
+}
+
+extern uint32_t nw, nh;
+void vidinterrupt() {
+	uint32_t tempcalc, memloc, n;
+	updatedscreen = 1;
+	switch (regs.byteregs[regah]) { //what video interrupt function?
+			case 0: //set video mode
+				if (verbose) {
+						printf ("Set video mode %02Xh\n", regs.byteregs[regal]);
+					}
+				VGA_SC[0x4] = 0; //VGA modes are in chained mode by default after a mode switch
+				//regs.byteregs[regal] = 3;
+				switch (regs.byteregs[regal] & 0x7F) {
+						case 0: //40x25 mono text
+							videobase = textbase;
+							cols = 40;
+							rows = 25;
+							vidcolor = 0;
+							vidgfxmode = 0;
+							blankattr = 7;
+							for (tempcalc = videobase; tempcalc<videobase+16384; tempcalc+=2) {
+									RAM[tempcalc] = 0;
+									RAM[tempcalc+1] = blankattr;
+								}
+							break;
+						case 1: //40x25 color text
+							videobase = textbase;
+							cols = 40;
+							rows = 25;
+							vidcolor = 1;
+							vidgfxmode = 0;
+							blankattr = 7;
+							for (tempcalc = videobase; tempcalc<videobase+16384; tempcalc+=2) {
+									RAM[tempcalc] = 0;
+									RAM[tempcalc+1] = blankattr;
+								}
+							portram[0x3D8] = portram[0x3D8] & 0xFE;
+							break;
+						case 2: //80x25 mono text
+							videobase = textbase;
+							cols = 80;
+							rows = 25;
+							vidcolor = 1;
+							vidgfxmode = 0;
+							blankattr = 7;
+							for (tempcalc = videobase; tempcalc<videobase+16384; tempcalc+=2) {
+									RAM[tempcalc] = 0;
+									RAM[tempcalc+1] = blankattr;
+								}
+							portram[0x3D8] = portram[0x3D8] & 0xFE;
+							break;
+						case 3: //80x25 color text
+							videobase = textbase;
+							cols = 80;
+							rows = 25;
+							vidcolor = 1;
+							vidgfxmode = 0;
+							blankattr = 7;
+							for (tempcalc = videobase; tempcalc<videobase+16384; tempcalc+=2) {
+									RAM[tempcalc] = 0;
+									RAM[tempcalc+1] = blankattr;
+								}
+							portram[0x3D8] = portram[0x3D8] & 0xFE;
+							break;
+						case 4:
+						case 5: //80x25 color text
+							videobase = textbase;
+							cols = 40;
+							rows = 25;
+							vidcolor = 1;
+							vidgfxmode = 1;
+							blankattr = 7;
+							for (tempcalc = videobase; tempcalc<videobase+16384; tempcalc+=2) {
+									RAM[tempcalc] = 0;
+									RAM[tempcalc+1] = blankattr;
+								}
+							if (regs.byteregs[regal]==4) portram[0x3D9] = 48;
+							else portram[0x3D9] = 0;
+							break;
+						case 6:
+							videobase = textbase;
+							cols = 80;
+							rows = 25;
+							vidcolor = 0;
+							vidgfxmode = 1;
+							blankattr = 7;
+							for (tempcalc = videobase; tempcalc<videobase+16384; tempcalc+=2) {
+									RAM[tempcalc] = 0;
+									RAM[tempcalc+1] = blankattr;
+								}
+							portram[0x3D8] = portram[0x3D8] & 0xFE;
+							break;
+						case 127:
+							videobase = 0xB8000;
+							cols = 90;
+							rows = 25;
+							vidcolor = 0;
+							vidgfxmode = 1;
+							for (tempcalc = videobase; tempcalc<videobase+16384; tempcalc++) {
+									RAM[tempcalc] = 0;
+								}
+							portram[0x3D8] = portram[0x3D8] & 0xFE;
+							break;
+						case 0x9: //320x200 16-color
+							videobase = 0xB8000;
+							cols = 40;
+							rows = 25;
+							vidcolor = 1;
+							vidgfxmode = 1;
+							blankattr = 0;
+							if ( (regs.byteregs[regal]&0x80) ==0) for (tempcalc = videobase; tempcalc<videobase+65535; tempcalc+=2) {
+										RAM[tempcalc] = 0;
+										RAM[tempcalc+1] = blankattr;
+									}
+							portram[0x3D8] = portram[0x3D8] & 0xFE;
+							break;
+						case 0xD: //320x200 16-color
+						case 0x12: //640x480 16-color
+						case 0x13: //320x200 256-color
+							videobase = 0xA0000;
+							cols = 40;
+							rows = 25;
+							vidcolor = 1;
+							vidgfxmode = 1;
+							blankattr = 0;
+							for (tempcalc = videobase; tempcalc<videobase+65535; tempcalc+=2) {
+									RAM[tempcalc] = 0;
+									RAM[tempcalc+1] = blankattr;
+								}
+							portram[0x3D8] = portram[0x3D8] & 0xFE;
+							break;
+					}
+				vidmode = regs.byteregs[regal] & 0x7F;
+				RAM[0x449] = vidmode;
+				RAM[0x44A] = (uint8_t) cols;
+				RAM[0x44B] = 0;
+				RAM[0x484] = (uint8_t) (rows - 1);
+				cursx = 0;
+				cursy = 0;
+				if ( (regs.byteregs[regal] & 0x80) == 0x00) {
+						memset (&RAM[0xA0000], 0, 0x1FFFF);
+						memset (VRAM, 0, 262144);
+					}
+				switch (vidmode) {
+						case 127: //hercules
+							nw = oldw = 720;
+							nh = oldh = 348;
+							scrmodechange = 1;
+							break;
+						case 0x12:
+							nw = oldw = 640;
+							nh = oldh = 480;
+							scrmodechange = 1;
+							break;
+						case 0x13:
+							oldw = 640;
+							oldh = 400;
+							nw = 320;
+							nh = 200;
+							scrmodechange = 1;
+							break;
+						default:
+							nw = oldw = 640;
+							nh = oldh = 400;
+							scrmodechange = 1;
+							break;
+					}
+				break;
+			case 0x10: //VGA DAC functions
+				switch (regs.byteregs[regal]) {
+						case 0x10: //set individual DAC register
+							palettevga[getreg16 (regbx) ] = rgb((regs.byteregs[regdh] & 63) << 2, (regs.byteregs[regch] & 63) << 2, (regs.byteregs[regcl] & 63) << 2);
+							break;
+						case 0x12: //set block of DAC registers
+							memloc = segregs[reges]*16+getreg16 (regdx);
+							for (n=getreg16 (regbx); n< (uint32_t) (getreg16 (regbx) +getreg16 (regcx) ); n++) {
+									palettevga[n] = rgb(read86(memloc) << 2, read86(memloc + 1) << 2, read86(memloc + 2) << 2);
+									memloc += 3;
+								}
+					}
+				break;
+			case 0x1A: //get display combination code (ps, vga/mcga)
+				regs.byteregs[regal] = 0x1A;
+				regs.byteregs[regbl] = 0x8;
+				break;
+		}
+}
+
+void initcga() {
+	FILE *fontfile;
+	fontfile = fopen (PATH_DATAFILES "asciivga.dat", "rb");
+	if (fontfile==NULL) {
+			printf ("FATAL: Cannot open " PATH_DATAFILES "asciivga!\n");
+			exit (1);
+		}
+	fread (&fontcga[0], 32768, 1, fontfile);
+	fclose (fontfile);
+
+	palettecga[0] = 0;
+	palettecga[1] = rgb (0, 0, 0xAA);
+	palettecga[2] = rgb (0, 0xAA, 0);
+	palettecga[3] = rgb (0, 0xAA, 0xAA);
+	palettecga[4] = rgb (0xAA, 0, 0);
+	palettecga[5] = rgb (0xAA, 0, 0xAA);
+	palettecga[6] = rgb (0xAA, 0x55, 0);
+	palettecga[7] = rgb (0xAA, 0xAA, 0xAA);
+	palettecga[8] = rgb (0x55, 0x55, 0x55);
+	palettecga[9] = rgb (0x55, 0x55, 0xFF);
+	palettecga[10] = rgb (0x55, 0xFF, 0x55);
+	palettecga[11] = rgb (0x55, 0xFF, 0xFF);
+	palettecga[12] = rgb (0xFF, 0x55, 0x55);
+	palettecga[13] = rgb (0xFF, 0x55, 0xFF);
+	palettecga[14] = rgb (0xFF, 0xFF, 0x55);
+	palettecga[15] = rgb (0xFF, 0xFF, 0xFF);
+	palettevga[0] = rgb (0, 0, 0);
+	palettevga[1] = rgb (0, 0, 169);
+	palettevga[2] = rgb (0, 169, 0);
+	palettevga[3] = rgb (0, 169, 169);
+	palettevga[4] = rgb (169, 0, 0);
+	palettevga[5] = rgb (169, 0, 169);
+	palettevga[6] = rgb (169, 169, 0);
+	palettevga[7] = rgb (169, 169, 169);
+	palettevga[8] = rgb (0, 0, 84);
+	palettevga[9] = rgb (0, 0, 255);
+	palettevga[10] = rgb (0, 169, 84);
+	palettevga[11] = rgb (0, 169, 255);
+	palettevga[12] = rgb (169, 0, 84);
+	palettevga[13] = rgb (169, 0, 255);
+	palettevga[14] = rgb (169, 169, 84);
+	palettevga[15] = rgb (169, 169, 255);
+	palettevga[16] = rgb (0, 84, 0);
+	palettevga[17] = rgb (0, 84, 169);
+	palettevga[18] = rgb (0, 255, 0);
+	palettevga[19] = rgb (0, 255, 169);
+	palettevga[20] = rgb (169, 84, 0);
+	palettevga[21] = rgb (169, 84, 169);
+	palettevga[22] = rgb (169, 255, 0);
+	palettevga[23] = rgb (169, 255, 169);
+	palettevga[24] = rgb (0, 84, 84);
+	palettevga[25] = rgb (0, 84, 255);
+	palettevga[26] = rgb (0, 255, 84);
+	palettevga[27] = rgb (0, 255, 255);
+	palettevga[28] = rgb (169, 84, 84);
+	palettevga[29] = rgb (169, 84, 255);
+	palettevga[30] = rgb (169, 255, 84);
+	palettevga[31] = rgb (169, 255, 255);
+	palettevga[32] = rgb (84, 0, 0);
+	palettevga[33] = rgb (84, 0, 169);
+	palettevga[34] = rgb (84, 169, 0);
+	palettevga[35] = rgb (84, 169, 169);
+	palettevga[36] = rgb (255, 0, 0);
+	palettevga[37] = rgb (255, 0, 169);
+	palettevga[38] = rgb (255, 169, 0);
+	palettevga[39] = rgb (255, 169, 169);
+	palettevga[40] = rgb (84, 0, 84);
+	palettevga[41] = rgb (84, 0, 255);
+	palettevga[42] = rgb (84, 169, 84);
+	palettevga[43] = rgb (84, 169, 255);
+	palettevga[44] = rgb (255, 0, 84);
+	palettevga[45] = rgb (255, 0, 255);
+	palettevga[46] = rgb (255, 169, 84);
+	palettevga[47] = rgb (255, 169, 255);
+	palettevga[48] = rgb (84, 84, 0);
+	palettevga[49] = rgb (84, 84, 169);
+	palettevga[50] = rgb (84, 255, 0);
+	palettevga[51] = rgb (84, 255, 169);
+	palettevga[52] = rgb (255, 84, 0);
+	palettevga[53] = rgb (255, 84, 169);
+	palettevga[54] = rgb (255, 255, 0);
+	palettevga[55] = rgb (255, 255, 169);
+	palettevga[56] = rgb (84, 84, 84);
+	palettevga[57] = rgb (84, 84, 255);
+	palettevga[58] = rgb (84, 255, 84);
+	palettevga[59] = rgb (84, 255, 255);
+	palettevga[60] = rgb (255, 84, 84);
+	palettevga[61] = rgb (255, 84, 255);
+	palettevga[62] = rgb (255, 255, 84);
+	palettevga[63] = rgb (255, 255, 255);
+	palettevga[64] = rgb (255, 125, 125);
+	palettevga[65] = rgb (255, 157, 125);
+	palettevga[66] = rgb (255, 190, 125);
+	palettevga[67] = rgb (255, 222, 125);
+	palettevga[68] = rgb (255, 255, 125);
+	palettevga[69] = rgb (222, 255, 125);
+	palettevga[70] = rgb (190, 255, 125);
+	palettevga[71] = rgb (157, 255, 125);
+	palettevga[72] = rgb (125, 255, 125);
+	palettevga[73] = rgb (125, 255, 157);
+	palettevga[74] = rgb (125, 255, 190);
+	palettevga[75] = rgb (125, 255, 222);
+	palettevga[76] = rgb (125, 255, 255);
+	palettevga[77] = rgb (125, 222, 255);
+	palettevga[78] = rgb (125, 190, 255);
+	palettevga[79] = rgb (125, 157, 255);
+	palettevga[80] = rgb (182, 182, 255);
+	palettevga[81] = rgb (198, 182, 255);
+	palettevga[82] = rgb (218, 182, 255);
+	palettevga[83] = rgb (234, 182, 255);
+	palettevga[84] = rgb (255, 182, 255);
+	palettevga[85] = rgb (255, 182, 234);
+	palettevga[86] = rgb (255, 182, 218);
+	palettevga[87] = rgb (255, 182, 198);
+	palettevga[88] = rgb (255, 182, 182);
+	palettevga[89] = rgb (255, 198, 182);
+	palettevga[90] = rgb (255, 218, 182);
+	palettevga[91] = rgb (255, 234, 182);
+	palettevga[92] = rgb (255, 255, 182);
+	palettevga[93] = rgb (234, 255, 182);
+	palettevga[94] = rgb (218, 255, 182);
+	palettevga[95] = rgb (198, 255, 182);
+	palettevga[96] = rgb (182, 255, 182);
+	palettevga[97] = rgb (182, 255, 198);
+	palettevga[98] = rgb (182, 255, 218);
+	palettevga[99] = rgb (182, 255, 234);
+	palettevga[100] = rgb (182, 255, 255);
+	palettevga[101] = rgb (182, 234, 255);
+	palettevga[102] = rgb (182, 218, 255);
+	palettevga[103] = rgb (182, 198, 255);
+	palettevga[104] = rgb (0, 0, 113);
+	palettevga[105] = rgb (28, 0, 113);
+	palettevga[106] = rgb (56, 0, 113);
+	palettevga[107] = rgb (84, 0, 113);
+	palettevga[108] = rgb (113, 0, 113);
+	palettevga[109] = rgb (113, 0, 84);
+	palettevga[110] = rgb (113, 0, 56);
+	palettevga[111] = rgb (113, 0, 28);
+	palettevga[112] = rgb (113, 0, 0);
+	palettevga[113] = rgb (113, 28, 0);
+	palettevga[114] = rgb (113, 56, 0);
+	palettevga[115] = rgb (113, 84, 0);
+	palettevga[116] = rgb (113, 113, 0);
+	palettevga[117] = rgb (84, 113, 0);
+	palettevga[118] = rgb (56, 113, 0);
+	palettevga[119] = rgb (28, 113, 0);
+	palettevga[120] = rgb (0, 113, 0);
+	palettevga[121] = rgb (0, 113, 28);
+	palettevga[122] = rgb (0, 113, 56);
+	palettevga[123] = rgb (0, 113, 84);
+	palettevga[124] = rgb (0, 113, 113);
+	palettevga[125] = rgb (0, 84, 113);
+	palettevga[126] = rgb (0, 56, 113);
+	palettevga[127] = rgb (0, 28, 113);
+	palettevga[128] = rgb (56, 56, 113);
+	palettevga[129] = rgb (68, 56, 113);
+	palettevga[130] = rgb (84, 56, 113);
+	palettevga[131] = rgb (97, 56, 113);
+	palettevga[132] = rgb (113, 56, 113);
+	palettevga[133] = rgb (113, 56, 97);
+	palettevga[134] = rgb (113, 56, 84);
+	palettevga[135] = rgb (113, 56, 68);
+	palettevga[136] = rgb (113, 56, 56);
+	palettevga[137] = rgb (113, 68, 56);
+	palettevga[138] = rgb (113, 84, 56);
+	palettevga[139] = rgb (113, 97, 56);
+	palettevga[140] = rgb (113, 113, 56);
+	palettevga[141] = rgb (97, 113, 56);
+	palettevga[142] = rgb (84, 113, 56);
+	palettevga[143] = rgb (68, 113, 56);
+	palettevga[144] = rgb (56, 113, 56);
+	palettevga[145] = rgb (56, 113, 68);
+	palettevga[146] = rgb (56, 113, 84);
+	palettevga[147] = rgb (56, 113, 97);
+	palettevga[148] = rgb (56, 113, 113);
+	palettevga[149] = rgb (56, 97, 113);
+	palettevga[150] = rgb (56, 84, 113);
+	palettevga[151] = rgb (56, 68, 113);
+	palettevga[152] = rgb (80, 80, 113);
+	palettevga[153] = rgb (89, 80, 113);
+	palettevga[154] = rgb (97, 80, 113);
+	palettevga[155] = rgb (105, 80, 113);
+	palettevga[156] = rgb (113, 80, 113);
+	palettevga[157] = rgb (113, 80, 105);
+	palettevga[158] = rgb (113, 80, 97);
+	palettevga[159] = rgb (113, 80, 89);
+	palettevga[160] = rgb (113, 80, 80);
+	palettevga[161] = rgb (113, 89, 80);
+	palettevga[162] = rgb (113, 97, 80);
+	palettevga[163] = rgb (113, 105, 80);
+	palettevga[164] = rgb (113, 113, 80);
+	palettevga[165] = rgb (105, 113, 80);
+	palettevga[166] = rgb (97, 113, 80);
+	palettevga[167] = rgb (89, 113, 80);
+	palettevga[168] = rgb (80, 113, 80);
+	palettevga[169] = rgb (80, 113, 89);
+	palettevga[170] = rgb (80, 113, 97);
+	palettevga[171] = rgb (80, 113, 105);
+	palettevga[172] = rgb (80, 113, 113);
+	palettevga[173] = rgb (80, 105, 113);
+	palettevga[174] = rgb (80, 97, 113);
+	palettevga[175] = rgb (80, 89, 113);
+	palettevga[176] = rgb (0, 0, 64);
+	palettevga[177] = rgb (16, 0, 64);
+	palettevga[178] = rgb (32, 0, 64);
+	palettevga[179] = rgb (48, 0, 64);
+	palettevga[180] = rgb (64, 0, 64);
+	palettevga[181] = rgb (64, 0, 48);
+	palettevga[182] = rgb (64, 0, 32);
+	palettevga[183] = rgb (64, 0, 16);
+	palettevga[184] = rgb (64, 0, 0);
+	palettevga[185] = rgb (64, 16, 0);
+	palettevga[186] = rgb (64, 32, 0);
+	palettevga[187] = rgb (64, 48, 0);
+	palettevga[188] = rgb (64, 64, 0);
+	palettevga[189] = rgb (48, 64, 0);
+	palettevga[190] = rgb (32, 64, 0);
+	palettevga[191] = rgb (16, 64, 0);
+	palettevga[192] = rgb (0, 64, 0);
+	palettevga[193] = rgb (0, 64, 16);
+	palettevga[194] = rgb (0, 64, 32);
+	palettevga[195] = rgb (0, 64, 48);
+	palettevga[196] = rgb (0, 64, 64);
+	palettevga[197] = rgb (0, 48, 64);
+	palettevga[198] = rgb (0, 32, 64);
+	palettevga[199] = rgb (0, 16, 64);
+	palettevga[200] = rgb (32, 32, 64);
+	palettevga[201] = rgb (40, 32, 64);
+	palettevga[202] = rgb (48, 32, 64);
+	palettevga[203] = rgb (56, 32, 64);
+	palettevga[204] = rgb (64, 32, 64);
+	palettevga[205] = rgb (64, 32, 56);
+	palettevga[206] = rgb (64, 32, 48);
+	palettevga[207] = rgb (64, 32, 40);
+	palettevga[208] = rgb (64, 32, 32);
+	palettevga[209] = rgb (64, 40, 32);
+	palettevga[210] = rgb (64, 48, 32);
+	palettevga[211] = rgb (64, 56, 32);
+	palettevga[212] = rgb (64, 64, 32);
+	palettevga[213] = rgb (56, 64, 32);
+	palettevga[214] = rgb (48, 64, 32);
+	palettevga[215] = rgb (40, 64, 32);
+	palettevga[216] = rgb (32, 64, 32);
+	palettevga[217] = rgb (32, 64, 40);
+	palettevga[218] = rgb (32, 64, 48);
+	palettevga[219] = rgb (32, 64, 56);
+	palettevga[220] = rgb (32, 64, 64);
+	palettevga[221] = rgb (32, 56, 64);
+	palettevga[222] = rgb (32, 48, 64);
+	palettevga[223] = rgb (32, 40, 64);
+	palettevga[224] = rgb (44, 44, 64);
+	palettevga[225] = rgb (48, 44, 64);
+	palettevga[226] = rgb (52, 44, 64);
+	palettevga[227] = rgb (60, 44, 64);
+	palettevga[228] = rgb (64, 44, 64);
+	palettevga[229] = rgb (64, 44, 60);
+	palettevga[230] = rgb (64, 44, 52);
+	palettevga[231] = rgb (64, 44, 48);
+	palettevga[232] = rgb (64, 44, 44);
+	palettevga[233] = rgb (64, 48, 44);
+	palettevga[234] = rgb (64, 52, 44);
+	palettevga[235] = rgb (64, 60, 44);
+	palettevga[236] = rgb (64, 64, 44);
+	palettevga[237] = rgb (60, 64, 44);
+	palettevga[238] = rgb (52, 64, 44);
+	palettevga[239] = rgb (48, 64, 44);
+	palettevga[240] = rgb (44, 64, 44);
+	palettevga[241] = rgb (44, 64, 48);
+	palettevga[242] = rgb (44, 64, 52);
+	palettevga[243] = rgb (44, 64, 60);
+	palettevga[244] = rgb (44, 64, 64);
+	palettevga[245] = rgb (44, 60, 64);
+	palettevga[246] = rgb (44, 52, 64);
+	palettevga[247] = rgb (44, 48, 64);
+	palettevga[248] = rgb (0, 0, 0);
+	palettevga[249] = rgb (0, 0, 0);
+	palettevga[250] = rgb (0, 0, 0);
+	palettevga[251] = rgb (0, 0, 0);
+	palettevga[252] = rgb (0, 0, 0);
+	palettevga[253] = rgb (0, 0, 0);
+	palettevga[254] = rgb (0, 0, 0);
+	palettevga[255] = rgb (0, 0, 0);
+}
+
+uint16_t vtotal = 0;
+void outVGA (uint16_t portnum, uint8_t value) {
+	static uint8_t oldah, oldal;
+	uint8_t flip3c0 = 0;
+	updatedscreen = 1;
+	switch (portnum) {
+			case 0x3B8: //hercules support
+				if ( ( (value & 2) == 2) && (vidmode != 127) ) {
+						oldah = regs.byteregs[regah];
+						oldal = regs.byteregs[regal];
+						regs.byteregs[regah] = 0;
+						regs.byteregs[regal] = 127;
+						vidinterrupt();
+						regs.byteregs[regah] = oldah;
+						regs.byteregs[regal] = oldal;
+					}
+				if (value & 0x80) videobase = 0xB8000;
+				else videobase = 0xB0000;
+				break;
+			case 0x3C0:
+				if (flip3c0) {
+						flip3c0 = 0;
+						portram[0x3C0] = value & 255;
+						return;
+					}
+				else {
+						flip3c0 = 1;
+						VGA_ATTR[portram[0x3C0]] = value & 255;
+						return;
+					}
+			case 0x3C4: //sequence controller index
+				portram[0x3C4] = value & 255;
+				//if (portout16) VGA_SC[value & 255] = value >> 8;
+				break;
+			case 0x3C5: //sequence controller data
+				VGA_SC[portram[0x3C4]] = value & 255;
+				/*if (portram[0x3C4] == 2) {
+				printf("VGA_SC[2] = %02X\n", value);
+				}*/
+				break;
+			case 0x3D4: //CRT controller index
+				portram[0x3D4] = value & 255;
+				//if (portout16) VGA_CRTC[value & 255] = value >> 8;
+				break;
+			case 0x3C7: //color index register (read operations)
+				latchReadPal = value & 255;
+				latchReadRGB = 0;
+				stateDAC = 0;
+				break;
+			case 0x3C8: //color index register (write operations)
+				latchPal = value & 255;
+				latchRGB = 0;
+				tempRGB = 0;
+				stateDAC = 3;
+				break;
+			case 0x3C9: //RGB data register
+				value = value & 63;
+				switch (latchRGB) {
+#ifdef __BIG_ENDIAN__
+						case 0: //red
+							tempRGB = value << 26;
+							break;
+						case 1: //green
+							tempRGB |= value << 18;
+							break;
+						case 2: //blue
+							tempRGB |= value << 10;
+							palettevga[latchPal] = tempRGB;
+							latchPal = latchPal + 1;
+							break;
+#else
+						case 0: //red
+							tempRGB = value << 2;
+							break;
+						case 1: //green
+							tempRGB |= value << 10;
+							break;
+						case 2: //blue
+							tempRGB |= value << 18;
+							palettevga[latchPal] = tempRGB;
+							latchPal = latchPal + 1;
+							break;
+#endif
+					}
+				latchRGB = (latchRGB + 1) % 3;
+				break;
+			case 0x3D5: //cursor position latch
+				VGA_CRTC[portram[0x3D4]] = value & 255;
+				if (portram[0x3D4]==0xE) cursorposition = (cursorposition&0xFF) | (value<<8);
+				else if (portram[0x3D4]==0xF) cursorposition = (cursorposition&0xFF00) |value;
+				cursy = cursorposition/cols;
+				cursx = cursorposition%cols;
+				if (portram[0x3D4] == 6) {
+						vtotal = value | ( ( (uint16_t) VGA_GC[7] & 1) << 8) | ( ( (VGA_GC[7] & 32) ? 1 : 0) << 9);
+						//printf("Vertical total: %u\n", vtotal);
+					}
+				break;
+			case 0x3CF:
+				VGA_GC[portram[0x3CE]] = value;
+				break;
+			default:
+				portram[portnum] = value;
+		}
+}
+
+uint8_t inVGA (uint16_t portnum) {
+	switch (portnum) {
+			case 0x3C1:
+				return ( (uint8_t) VGA_ATTR[portram[0x3C0]]);
+			case 0x3C5:
+				return ( (uint8_t) VGA_SC[portram[0x3C4]]);
+			case 0x3D5:
+				return ( (uint8_t) VGA_CRTC[portram[0x3D4]]);
+			case 0x3C7: //DAC state
+				return (stateDAC);
+			case 0x3C8: //palette index
+				return (latchReadPal);
+			case 0x3C9: //RGB data register
+				switch (latchReadRGB++) {
+#ifdef __BIG_ENDIAN__
+						case 0: //blue
+							return ( (palettevga[latchReadPal] >> 26) & 63);
+						case 1: //green
+							return ( (palettevga[latchReadPal] >> 18) & 63);
+						case 2: //red
+							latchReadRGB = 0;
+							return ( (palettevga[latchReadPal++] >> 10) & 63);
+#else
+						case 0: //blue
+							return ( (palettevga[latchReadPal] >> 2) & 63);
+						case 1: //green
+							return ( (palettevga[latchReadPal] >> 10) & 63);
+						case 2: //red
+							latchReadRGB = 0;
+							return ( (palettevga[latchReadPal++] >> 18) & 63);
+#endif
+					}
+			case 0x3DA:
+				return (port3da);
+		}
+	return (portram[portnum]); //this won't be reached, but without it the compiler gives a warning
+}
+
+#define shiftVGA(value) {\
+	for (cnt=0; cnt<(VGA_GC[3] & 7); cnt++) {\
+		value = (value >> 1) | ((value & 1) << 7);\
+	}\
+}
+
+#define logicVGA(curval, latchval) {\
+	switch ((VGA_GC[3]>>3) & 3) {\
+		   case 1: curval &= latchval; break;\
+		   case 2: curval |= latchval; break;\
+		   case 3: curval ^= latchval; break;\
+	}\
+}
+
+uint8_t lastmode = 0, tempvalue;
+void writeVGA (uint32_t addr32, uint8_t value) {
+	uint32_t planesize;
+	uint8_t curval, tempand, cnt;
+	updatedscreen = 1;
+	planesize = 0x10000;
+	//if (lastmode != VGA_GC[5] & 3) printf("write mode %u\n", VGA_GC[5] & 3);
+	//lastmode = VGA_GC[5] & 3;
+	switch (VGA_GC[5] & 3) { //get write mode
+			case 0:
+				shiftVGA (value);
+				if (VGA_SC[2] & 1) {
+						if (VGA_GC[1] & 1)
+							if (VGA_GC[0] & 1) curval = 255;
+							else curval = 0;
+						else curval = value;
+						logicVGA (curval, VGA_latch[0]);
+						curval = (~VGA_GC[8] & curval) | (VGA_GC[8] & VGA_latch[0]);
+						VRAM[addr32] = curval;
+					}
+				if (VGA_SC[2] & 2) {
+						if (VGA_GC[1] & 2)
+							if (VGA_GC[0] & 2) curval = 255;
+							else curval = 0;
+						else curval = value;
+						logicVGA (curval, VGA_latch[1]);
+						curval = (~VGA_GC[8] & curval) | (VGA_GC[8] & VGA_latch[1]);
+						VRAM[addr32+planesize] = curval;
+					}
+				if (VGA_SC[2] & 4) {
+						if (VGA_GC[1] & 4)
+							if (VGA_GC[0] & 4) curval = 255;
+							else curval = 0;
+						else curval = value;
+						logicVGA (curval, VGA_latch[2]);
+						curval = (~VGA_GC[8] & curval) | (VGA_GC[8] & VGA_latch[2]);
+						VRAM[addr32+planesize*2] = curval;
+					}
+				if (VGA_SC[2] & 8) {
+						if (VGA_GC[1] & 8)
+							if (VGA_GC[0] & 8) curval = 255;
+							else curval = 0;
+						else curval = value;
+						logicVGA (curval, VGA_latch[3]);
+						curval = (~VGA_GC[8] & curval) | (VGA_GC[8] & VGA_latch[3]);
+						VRAM[addr32+planesize*3] = curval;
+					}
+				break;
+			case 1:
+				if (VGA_SC[2] & 1) VRAM[addr32] = VGA_latch[0];
+				if (VGA_SC[2] & 2) VRAM[addr32+planesize] = VGA_latch[1];
+				if (VGA_SC[2] & 4) VRAM[addr32+planesize*2] = VGA_latch[2];
+				if (VGA_SC[2] & 8) VRAM[addr32+planesize*3] = VGA_latch[3];
+				break;
+			case 2:
+				if (VGA_SC[2] & 1) {
+						if (VGA_GC[1] & 1)
+							if (value & 1) curval = 255;
+							else curval = 0;
+						else curval = value;
+						logicVGA (curval, VGA_latch[0]);
+						curval = (~VGA_GC[8] & curval) | (VGA_GC[8] & VGA_latch[0]);
+						VRAM[addr32] = curval;
+					}
+				if (VGA_SC[2] & 2) {
+						if (VGA_GC[1] & 2)
+							if (value & 2) curval = 255;
+							else curval = 0;
+						else curval = value;
+						logicVGA (curval, VGA_latch[1]);
+						curval = (~VGA_GC[8] & curval) | (VGA_GC[8] & VGA_latch[1]);
+						VRAM[addr32+planesize] = curval;
+					}
+				if (VGA_SC[2] & 4) {
+						if (VGA_GC[1] & 4)
+							if (value & 4) curval = 255;
+							else curval = 0;
+						else curval = value;
+						logicVGA (curval, VGA_latch[2]);
+						curval = (~VGA_GC[8] & curval) | (VGA_GC[8] & VGA_latch[2]);
+						VRAM[addr32+planesize*2] = curval;
+					}
+				if (VGA_SC[2] & 8) {
+						if (VGA_GC[1] & 8)
+							if (value & 8) curval = 255;
+							else curval = 0;
+						else curval = value;
+						logicVGA (curval, VGA_latch[3]);
+						curval = (~VGA_GC[8] & curval) | (VGA_GC[8] & VGA_latch[3]);
+						VRAM[addr32+planesize*3] = curval;
+					}
+				break;
+			case 3:
+				tempand = value & VGA_GC[8];
+				shiftVGA (value);
+				if (VGA_SC[2] & 1) {
+						if (VGA_GC[0] & 1) curval = 255;
+						else curval = 0;
+						//logicVGA (curval, VGA_latch[0]);
+						curval = (~tempand & curval) | (tempand & VGA_latch[0]);
+						VRAM[addr32] = curval;
+					}
+				if (VGA_SC[2] & 2) {
+						if (VGA_GC[0] & 2) curval = 255;
+						else curval = 0;
+						//logicVGA (curval, VGA_latch[1]);
+						curval = (~tempand & curval) | (tempand & VGA_latch[1]);
+						VRAM[addr32+planesize] = curval;
+					}
+				if (VGA_SC[2] & 4) {
+						if (VGA_GC[0] & 4) curval = 255;
+						else curval = 0;
+						//logicVGA (curval, VGA_latch[2]);
+						curval = (~tempand & curval) | (tempand & VGA_latch[2]);
+						VRAM[addr32+planesize*2] = curval;
+					}
+				if (VGA_SC[2] & 8) {
+						if (VGA_GC[0] & 8) curval = 255;
+						else curval = 0;
+						//logicVGA (curval, VGA_latch[3]);
+						curval = (~tempand & curval) | (tempand & VGA_latch[3]);
+						VRAM[addr32+planesize*3] = curval;
+					}
+				break;
+		}
+}
+
+uint8_t readmode;
+uint32_t readmap;
+uint8_t readVGA (uint32_t addr32) {
+	uint32_t planesize;
+	planesize = 0x10000;
+
+	VGA_latch[0] = VRAM[addr32];
+	VGA_latch[1] = VRAM[addr32+planesize];
+	VGA_latch[2] = VRAM[addr32+planesize*2];
+	VGA_latch[3] = VRAM[addr32+planesize*3];
+	if (VGA_SC[2] & 1) return (VRAM[addr32]);
+	if (VGA_SC[2] & 2) return (VRAM[addr32+planesize]);
+	if (VGA_SC[2] & 4) return (VRAM[addr32+planesize*2]);
+	if (VGA_SC[2] & 8) return (VRAM[addr32+planesize*3]);
+	return (0); //this won't be reached, but without it some compilers give a warning
+}
+
+void initVideoPorts() {
+	set_port_write_redirector (0x3B0, 0x3DA, &outVGA);
+	set_port_read_redirector (0x3B0, 0x3DA, &inVGA);
+}
diff --git a/src/fake86/win32/menus.c b/src/fake86/win32/menus.c
new file mode 100644
index 0000000..738798a
--- /dev/null
+++ b/src/fake86/win32/menus.c
@@ -0,0 +1,161 @@
+#include "../config.h"
+#include "../../../win32/resource.h"
+#include <Windows.h>
+#include <SDL/SDL.h>
+#include <SDL/SDL_syswm.h>
+
+HWND myWindow;
+HINSTANCE myInstance;
+HMENU myMenu;
+WNDPROC oldProc;
+HWND GetHwnd();
+HICON myIcon;
+void SetWndProc();
+void MenuItemClick(WPARAM wParam);
+
+void ShowMenu() {
+	SetMenu(myWindow, myMenu);
+}
+
+void HideMenu() {
+	SetMenu(myWindow, NULL);
+}
+
+void initmenus() {
+	myWindow = GetHwnd();
+	myInstance = GetModuleHandle(NULL);
+	myMenu = LoadMenu(NULL, MAKEINTRESOURCE(IDR_MENU1));
+	ShowMenu();
+	SetWndProc();
+	//myIcon = LoadIcon(myInstance, MAKEINTRESOURCE(IDI_ICON1));
+	//SetClassLong(myWindow, GCLP_HICON, (LONG)(uint64_t)myIcon);
+	//SetClassLong(myWindow, GCLP_HICONSM, (LONG)(uint64_t)myIcon);
+
+	return;
+}
+
+HWND GetHwnd() {
+	SDL_SysWMinfo wmi;
+	SDL_VERSION(&wmi.version);
+
+	if (!SDL_GetWMInfo(&wmi)) return(NULL);
+	return(wmi.window);
+}
+
+LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
+	switch (msg) {
+		case WM_COMMAND:
+			MenuItemClick(wParam);
+			return(TRUE);
+	}
+
+	return(CallWindowProc(oldProc, hwnd, msg, wParam, lParam));
+}
+
+void SetWndProc() {
+	oldProc = (WNDPROC)SetWindowLong(myWindow, GWL_WNDPROC, (LONG_PTR)WndProc);
+}
+
+extern uint8_t running, bootdrive, dohardreset, scrmodechange;
+extern uint16_t constantw, constanth;
+uint8_t insertdisk (uint8_t drivenum, char *filename);
+uint8_t ejectdisk (uint8_t drivenum);
+
+void MenuItemClick(WPARAM wParam) {
+	OPENFILENAME of_dlg;
+	uint8_t filename[MAX_PATH] = { 0 };
+
+	switch (LOWORD(wParam)) {
+		//file menu
+		case ID_FILE_EXIT:
+			running = 0;
+			break;
+
+		//emulation menu
+		case ID_EMULATION_HARDRESETEMULATOR:
+			dohardreset = 1;
+			break;
+
+		case ID_FLOPPY0_INSERTDISK:
+		case ID_FLOPPY1_INSERTDISK:
+			memset(&of_dlg, 0, sizeof(of_dlg));
+			of_dlg.lStructSize = sizeof(of_dlg);
+			of_dlg.lpstrTitle = "Open disk image";
+			of_dlg.hInstance = NULL;
+			of_dlg.lpstrFile = filename;
+			of_dlg.lpstrFilter = "Floppy disk images (*.img)\0*.img\0All files (*.*)\0*.*\0\0";
+			of_dlg.nMaxFile = MAX_PATH;
+			of_dlg.Flags = OFN_FILEMUSTEXIST | OFN_LONGNAMES;
+			if (GetOpenFileName(&of_dlg)) {
+				if (LOWORD(wParam) == ID_FLOPPY0_INSERTDISK) {
+					insertdisk(0, (char *)of_dlg.lpstrFile);
+					if (bootdrive == 255) bootdrive = 0;
+				} else insertdisk(1, (char *)of_dlg.lpstrFile);
+			}
+			break;
+		case ID_FLOPPY0_EJECTDISK:
+			ejectdisk(0);
+			break;
+		case ID_FLOPPY1_EJECTDISK:
+			ejectdisk(1);
+			break;
+
+		case ID_HARDDRIVE0_INSERTDISK:
+		case ID_HARDDRIVE1_INSERTDISK:
+			memset(&of_dlg, 0, sizeof(of_dlg));
+			of_dlg.lStructSize = sizeof(of_dlg);
+			of_dlg.lpstrTitle = "Open disk image";
+			of_dlg.hInstance = NULL;
+			of_dlg.lpstrFile = filename;
+			of_dlg.lpstrFilter = "Raw disk images (*.raw, *.img)\0*.raw;*.img\0All files (*.*)\0*.*\0\0";
+			of_dlg.nMaxFile = MAX_PATH;
+			of_dlg.Flags = OFN_FILEMUSTEXIST | OFN_LONGNAMES;
+			if (GetOpenFileName(&of_dlg)) {
+				if (LOWORD(wParam) == ID_HARDDRIVE0_INSERTDISK) {
+					insertdisk(128, (char *)of_dlg.lpstrFile);
+					if (bootdrive == 255) bootdrive = 128;
+				} else insertdisk(129, (char *)of_dlg.lpstrFile);
+			}
+			break;
+		case ID_HARDDRIVE0_EJECTDISK:
+			ejectdisk(128);
+			break;
+		case ID_HARDDRIVE1_EJECTDISK:
+			ejectdisk(129);
+			break;
+
+		case ID_SETBOOTDRIVE_FLOPPY0:
+			bootdrive = 0;
+			break;
+		case ID_SETBOOTDRIVE_HARDDRIVE0:
+			bootdrive = 128;
+			break;
+
+		//video menu
+		case ID_WINDOWRESOLUTION_AUTOMATIC:
+			constantw = 0;
+			constanth = 0;
+			scrmodechange = 1;
+			break;
+		case ID_WINDOWRESOLUTION_320X200:
+			constantw = 320;
+			constanth = 200;
+			scrmodechange = 1;
+			break;
+		case ID_WINDOWRESOLUTION_640X400:
+			constantw = 640;
+			constanth = 400;
+			scrmodechange = 1;
+			break;
+		case ID_WINDOWRESOLUTION_960X600:
+			constantw = 960;
+			constanth = 600;
+			scrmodechange = 1;
+			break;
+		case ID_WINDOWRESOLUTION_1280X800:
+			constantw = 1280;
+			constanth = 800;
+			scrmodechange = 1;
+			break;
+	}
+}
diff --git a/src/fake86/win32/resource.h b/src/fake86/win32/resource.h
new file mode 100644
index 0000000..d6b04fe
--- /dev/null
+++ b/src/fake86/win32/resource.h
diff --git a/src/imagegen/imagegen.c b/src/imagegen/imagegen.c
new file mode 100755
index 0000000..5a5cafb
--- /dev/null
+++ b/src/imagegen/imagegen.c
@@ -0,0 +1,68 @@
+/*
+  Imagegen: A blank disk image generator for use with Fake86
+  Copyright (C)2010-2012 Mike Chambers
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+const char *build = "Imagegen v1.1";
+
+int main(int argc, char *argv[]) {
+	FILE			*image;
+	char			*blank;
+	unsigned long	i, size;
+
+	printf("%s (c)2010-2012 Mike Chambers\n", build);
+	printf("[Blank disk image generator for Fake86]\n\n");
+
+	if(argc < 3) {
+		printf("Usage syntax:\n");
+		printf("    imagegen imagefile size\n\n");
+		printf("imagefile denotes the filename of the new disk image to create.\n");
+		printf("size denotes the size in megabytes that it should be.\n");
+		return(1);
+	}
+
+	size = atoi(argv[2]);
+	if((size > 503) || !size) {
+		printf("Invalid size specified! Valid range is 1 to 503 MB.\n");
+		return(1);
+	}
+
+	image = fopen(argv[1], "wb");
+	if(image == NULL) {
+		printf("Unable to create new file: %s\n", argv[1]);
+		return(1);
+	}
+
+	blank = (void *)malloc(1048576);
+	if (blank == NULL) {
+		printf("Unable to allocate enough memory!\n");
+		return(1);
+	}
+
+	printf("Please wait, generating new image...\n");
+
+	for(i = 0; i < size; i++) {
+		fwrite(&blank[0], 1048576, 1, image);
+		printf("\rWriting to file: %u MB", i);
+	}
+
+	printf(" complete.\n");
+	return(0);
+}