From 4d3949def59915d485d75d11270b279c7570e85c Mon Sep 17 00:00:00 2001
From: umjammer <umjammer@gmail.com>
Date: Tue, 21 Nov 2017 09:36:54 +0900
Subject: [PATCH] tidy up

---
 appleii.txt                                   |   22 +-
 build.xml                                     |   11 +-
 .../java/vavi/apps/appleii/AppleDisplay.java  | 1776 ++++-----
 .../java/vavi/apps/appleii/AppleIIApp.java    |   70 +-
 .../java/vavi/apps/appleii/AppleIIGo.java     |  280 +-
 src/main/java/vavi/apps/appleii/DiskII.java   |  782 ++--
 src/main/java/vavi/apps/appleii/Em6502.java   | 3200 ++++++++---------
 .../java/vavi/apps/appleii/EmAppleII.java     | 2168 +++++------
 src/main/java/vavi/apps/appleii/Paddle.java   |  166 +-
 .../java/vavi/apps/appleii/Peripheral.java    |   24 +-
 .../vavi/apps/appleii/VirtualKeyboard.java    |   38 +-
 .../apps/appleii/VirtualKeyboardListener.java |   20 +-
 .../apps/appleii/VirtualKeyboardTest.java     |    4 +-
 13 files changed, 4281 insertions(+), 4280 deletions(-)

diff --git a/appleii.txt b/appleii.txt
index a04e711..7651838 100644
--- a/appleii.txt
+++ b/appleii.txt
@@ -21,15 +21,15 @@ http://vavivavi.blogspot.com/
 
 * DONE
 
-	improve pad control
+        improve pad control
         disk selection mode
         virtual keyboard
-	.nib reader
+        .nib reader
 
 * INSTALL
 
-	1. unpack bdjappleii-x.xx.rar
-	
+        1. unpack bdjappleii-x.xx.rar
+        
         2. copy AVCHD directory into
         
             (SD Card) /PRIVATE directory
@@ -38,7 +38,7 @@ http://vavivavi.blogspot.com/
 
         3. copy APPLE2E.ROM into .../AVCHD directory
         
-        4. copy your .dsk image into .../AVCHD directory
+        4. copy your .dsk or .nib image into .../AVCHD directory
 
         5. modify .../AVCHD/appleii.properties
         
@@ -70,7 +70,7 @@ http://vavivavi.blogspot.com/
             BLUE Button         Goto DISK DRIVE 1 MODE
             GREEN Button        Restart
 
-	3. DISK DRIVE 1 MODE
+        3. DISK DRIVE 1 MODE
 
             CIRCLE              Select disk image
             SQUARE              Release disk image
@@ -79,7 +79,7 @@ http://vavivavi.blogspot.com/
             BLUE Button         Goto DISK DRIVE 2 MODE
             GREEN Button        Restart
 
-	4. DISK DRIVE 2 MODE
+        4. DISK DRIVE 2 MODE
 
             CIRCLE              Select disk image
             SQUARE              Release disk image
@@ -91,7 +91,7 @@ http://vavivavi.blogspot.com/
 * ROMz
 
         http://apple2.org.za/gswv/a2zine/System/
-	ftp://ftp.apple.asimov.net/pub/apple_II/
+        ftp://ftp.apple.asimov.net/pub/apple_II/
         
 * GAMEz
 
@@ -101,7 +101,7 @@ http://vavivavi.blogspot.com/
 
 0.12    09-Oct-2008
 
-	improve pad control (i fogot keyReleased() method calling at base ;-P)
+        improve pad control (i forgot keyReleased() method calling at base ;-P)
 
 0.11    28-Sep-2008
 
@@ -110,8 +110,8 @@ http://vavivavi.blogspot.com/
 0.10    26-Sep-2008
 
         virtual keyboard
-	add disk selection mode
-	.nib reader
+        add disk selection mode
+        .nib reader
 
 0.00    15-Sep-2008
 
diff --git a/build.xml b/build.xml
index bfc92b1..30c094d 100644
--- a/build.xml
+++ b/build.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="Windows-31J"?>
+<?xml version="1.0" encoding="UTf-8"?>
 
 <!-- ////////////////////////////////////////////////////////////////////// -->
 <!-- Copyright (c) 2008 by umjammer, All rights reserved.                   -->
@@ -7,13 +7,14 @@
 <!--                                                                        -->
 <!-- BD-J Apple II                                                          -->
 <!--                                                                        -->
-<!-- @author	umjammer                                                    -->
-<!-- @version	0.00	080912	nsano	initial version                     -->
+<!-- @author umjammer                                                       -->
+<!-- @version 0.00 080912 umjammer initial version                          -->
 <!--                                                                        -->
 <!-- ////////////////////////////////////////////////////////////////////// -->
 
 <project name="bdj Apple II" default="run" basedir=".">
 
+  <property environment="env"/>
   <property file="local.properties" />
 
   <property name="dir.build" value="build"/>
@@ -57,7 +58,7 @@
            destdir="${dir.build}"
            source="1.3"
            target="1.3"
-	   deprecation="true">
+           deprecation="true">
 <!--
       <bootclasspath>
         <pathelement location="${dir.bdj}/lib/basis.jar" />
@@ -123,7 +124,7 @@
         <include name="**/*.properties" />
       </fileset>
     </copy>
-    
+
     <java jar="${dir.bdj}/common/xletview.jar" fork="yes">
 <!--
       <jvmarg value="-Xprof"/>
diff --git a/src/main/java/vavi/apps/appleii/AppleDisplay.java b/src/main/java/vavi/apps/appleii/AppleDisplay.java
index b2d2e16..cd4a137 100644
--- a/src/main/java/vavi/apps/appleii/AppleDisplay.java
+++ b/src/main/java/vavi/apps/appleii/AppleDisplay.java
@@ -13,98 +13,98 @@ package vavi.apps.appleii;
  * Refreshes the display
  */
 public class AppleDisplay implements Runnable {
-	// Instances of other classes
+    // Instances of other classes
     private EmAppleII apple;
 
-	// Configuration variables
-	public static final int COLORMODE_GREEN = 0;
-	public static final int COLORMODE_COLOR = 1;
-	
-	private int colorMode;
+    // Configuration variables
+    public static final int COLORMODE_GREEN = 0;
+    public static final int COLORMODE_COLOR = 1;
 
-	// Refresh
-	private int refreshRate;
-	private long refreshInterval;
-	private long refreshDelayCumulative;
-	private long refreshDelayPerSecond;
-	private long refreshCycle;
+    private int colorMode;
 
-	private boolean isPrecalcRequested = true;
-	private boolean isRefreshRequested = true;
-	
-	// Graphics interface variables
+    // Refresh
+    private int refreshRate;
+    private long refreshInterval;
+    private long refreshDelayCumulative;
+    private long refreshDelayPerSecond;
+    private long refreshCycle;
+
+    private boolean isPrecalcRequested = true;
+    private boolean isRefreshRequested = true;
+
+    // Graphics interface variables
     private boolean[] graphicsDirty = new boolean[0x6000 >> 7];
-	private int graphicsMode;
+    private int graphicsMode;
 
-	// Display
-	private static final int DISPLAY_CHAR_SIZE_X = 7;
-	private static final int DISPLAY_CHAR_SIZE_Y = 8;
-	private static final int DISPLAY_CHAR_COUNT_X = 80;
-	private static final int DISPLAY_CHAR_COUNT_Y = 24;
-	public static final int DISPLAY_SIZE_X = DISPLAY_CHAR_COUNT_X * DISPLAY_CHAR_SIZE_X;
-	public static final int DISPLAY_SIZE_Y = DISPLAY_CHAR_COUNT_Y * DISPLAY_CHAR_SIZE_Y;
+    // Display
+    private static final int DISPLAY_CHAR_SIZE_X = 7;
+    private static final int DISPLAY_CHAR_SIZE_Y = 8;
+    private static final int DISPLAY_CHAR_COUNT_X = 80;
+    private static final int DISPLAY_CHAR_COUNT_Y = 24;
+    public static final int DISPLAY_SIZE_X = DISPLAY_CHAR_COUNT_X * DISPLAY_CHAR_SIZE_X;
+    public static final int DISPLAY_SIZE_Y = DISPLAY_CHAR_COUNT_Y * DISPLAY_CHAR_SIZE_Y;
 
-	// Display composition
-	private int[] displayImageBuffer;
-	
-	public int[] getDisplayImageBuffer() {
+    // Display composition
+    private int[] displayImageBuffer;
+
+    public int[] getDisplayImageBuffer() {
         return displayImageBuffer;
     }
 
     // Display scale
-	private float displayScale;
+    private float displayScale;
 
-	// Display palette
-	private int[] displayPalette;
-	private static final int[] displayPaletteGreen = {
-		0xff000000, 0xff0e470e, 0xff041204, 0xff166e16,
-		0xff0f4a0f, 0xff115411, 0xff0c3b0c, 0xff1f9e1f,
-		0xff125c12, 0xff1b8a1b, 0xff22ab22, 0xff24b524,
-		0xff1A871a, 0xff2de32d, 0xff25bd25, 0xff32ff32
-	};
-	private static final int[] displayPaletteColor = {
-		0xff000000, 0xffdd0033, 0xff000099, 0xffdd22dd,
-		0xff007722, 0xff555555, 0xff2222ff, 0xff66aaff,
-		0xff885500, 0xffff6600, 0xffaaaaaa, 0xffff9988,
-		0xff11dd00, 0xffffff00, 0xff44ff99, 0xffffffff
-	};
+    // Display palette
+    private int[] displayPalette;
+    private static final int[] displayPaletteGreen = {
+        0xff000000, 0xff0e470e, 0xff041204, 0xff166e16,
+        0xff0f4a0f, 0xff115411, 0xff0c3b0c, 0xff1f9e1f,
+        0xff125c12, 0xff1b8a1b, 0xff22ab22, 0xff24b524,
+        0xff1A871a, 0xff2de32d, 0xff25bd25, 0xff32ff32
+    };
+    private static final int[] displayPaletteColor = {
+        0xff000000, 0xffdd0033, 0xff000099, 0xffdd22dd,
+        0xff007722, 0xff555555, 0xff2222ff, 0xff66aaff,
+        0xff885500, 0xffff6600, 0xffaaaaaa, 0xffff9988,
+        0xff11dd00, 0xffffff00, 0xff44ff99, 0xffffffff
+    };
 
-	// Character stuff
-	private static final int CHARSET_CHAR_SIZE_X = 8;
-	private static final int CHARSET_CHAR_SIZE_Y = 8;
-	private static final int CHARSET_SIZE_X = 0x100 * CHARSET_CHAR_SIZE_X;
-	private static final int CHARSET_SIZE_Y = CHARSET_CHAR_SIZE_Y;
+    // Character stuff
+    private static final int CHARSET_CHAR_SIZE_X = 8;
+    private static final int CHARSET_CHAR_SIZE_Y = 8;
+    private static final int CHARSET_SIZE_X = 0x100 * CHARSET_CHAR_SIZE_X;
+    private static final int CHARSET_SIZE_Y = CHARSET_CHAR_SIZE_Y;
 
-	private static final int CHARMAP_NORMAL = 0;
-	private static final int CHARMAP_FLASH = 1;
-	private static final int CHARMAP_ALT = 2;
+    private static final int CHARMAP_NORMAL = 0;
+    private static final int CHARMAP_FLASH = 1;
+    private static final int CHARMAP_ALT = 2;
 
-	private int[] charSet = new int[CHARSET_SIZE_X * CHARSET_CHAR_SIZE_Y];
-	private int[] charMap;
-	private int[][] charMaps = new int[3][0x100];
-	private long charMapFlashCycle = 0;
-	private boolean isCharMapFlash = false;
+    private int[] charSet = new int[CHARSET_SIZE_X * CHARSET_CHAR_SIZE_Y];
+    private int[] charMap;
+    private int[][] charMaps = new int[3][0x100];
+    private long charMapFlashCycle = 0;
+    private boolean isCharMapFlash = false;
 
-	private int[][] charMapLookup = {
-		{ 0xc0, 0xa0, 0x40, 0x20, 0x40, 0x20, 0x40, 0x60 },
-		{ 0xc0, 0xa0, 0xc0, 0xa0, 0x40, 0x20, 0x40, 0x60 },
-		{ 0xc0, 0xa0, 0x00, 0xe0, 0x40, 0x20, 0x40, 0x60 },
-	};
+    private int[][] charMapLookup = {
+        { 0xc0, 0xa0, 0x40, 0x20, 0x40, 0x20, 0x40, 0x60 },
+        { 0xc0, 0xa0, 0xc0, 0xa0, 0x40, 0x20, 0x40, 0x60 },
+        { 0xc0, 0xa0, 0x00, 0xe0, 0x40, 0x20, 0x40, 0x60 },
+    };
 
-	private static final int[] textLineAddress = {
-		0x0000, 0x0080, 0x0100, 0x0180, 0x0200, 0x0280, 0x0300, 0x0380,
-		0x0028, 0x00a8, 0x0128, 0x01a8, 0x0228, 0x02a8, 0x0328, 0x03a8,
-		0x0050, 0x00d0, 0x0150, 0x01d0, 0x0250, 0x02d0, 0x0350, 0x03d0,
-	};
+    private static final int[] textLineAddress = {
+        0x0000, 0x0080, 0x0100, 0x0180, 0x0200, 0x0280, 0x0300, 0x0380,
+        0x0028, 0x00a8, 0x0128, 0x01a8, 0x0228, 0x02a8, 0x0328, 0x03a8,
+        0x0050, 0x00d0, 0x0150, 0x01d0, 0x0250, 0x02d0, 0x0350, 0x03d0,
+    };
 
-	// Hires stuff
-	private int hiresEvenOddToWord[] = new int[0x200];
-	private int hiresWord[] = new int[8];
-	private int hiresWordNext[] = new int[8];
-	private int hiresLookup[] = new int[0x100];	// Bits: [NNccccPP] - Next, current, Previous bits
-	private static final int hiresLookupColor[] = {
-		// Bits: [PPNNcccc] - Previous, Next, current bits => 4 pixel @ 4 bit color output
-	    // Color-bleeding algorithm
+    // Hires stuff
+    private int hiresEvenOddToWord[] = new int[0x200];
+    private int hiresWord[] = new int[8];
+    private int hiresWordNext[] = new int[8];
+    private int hiresLookup[] = new int[0x100];    // Bits: [NNccccPP] - Next, current, Previous bits
+    private static final int hiresLookupColor[] = {
+        // Bits: [PPNNcccc] - Previous, Next, current bits => 4 pixel @ 4 bit color output
+        // Color-bleeding algorithm
         0x0000, 0x0111, 0x2222, 0x2333, 0x4440, 0x4551, 0x6662, 0x6773, 0x8800, 0x8911, 0xaa22, 0xab33, 0xcc40, 0xcd51, 0xee62, 0xef73, // 00cccc00
         0x1000, 0x1111, 0x3222, 0x3333, 0x5440, 0x5551, 0x7662, 0x7773, 0x9800, 0x9911, 0xba22, 0xbb33, 0xdc40, 0xdd51, 0xfe62, 0xff73, // 01cccc00
         0x0000, 0x0111, 0x2222, 0x2333, 0x4440, 0x4551, 0x6662, 0x6773, 0x8800, 0x8911, 0xaa22, 0xab33, 0xcc40, 0xcd51, 0xee62, 0xef73, // 10cccc00
@@ -139,908 +139,908 @@ public class AppleDisplay implements Runnable {
         0x0000, 0x0001, 0x0020, 0x0033, 0x0400, 0x0505, 0x0660, 0x0777, 0x8000, 0x9009, 0xa0a0, 0xb0bb, 0xcc00, 0xdddd, 0xeee0, 0xffff, // 01cccc11
         0x0000, 0x0001, 0x0020, 0x0033, 0x0400, 0x0505, 0x0660, 0x0777, 0x8000, 0x9009, 0xa0a0, 0xb0bb, 0xcc00, 0xdd0d, 0xeeee, 0xffff, // 10cccc11
         0x0000, 0x000f, 0x00f0, 0x00ff, 0x0f00, 0x0f0f, 0x0ff0, 0x0fff, 0xf000, 0xf00f, 0xf0f0, 0xf0ff, 0xff00, 0xff0f, 0xfff0, 0xffff, // 11cccc11
-	};
-	private int[] doubleHiresPalette;
-	private static final int[] doubleHiresPaletteColor = {
-		0x000000, 0x000099, 0x007722, 0x2222ff, 
-		0x885500, 0xaaaaaa, 0x11dd00, 0x44ff99, 
-		0xdd0033, 0xdd22dd, 0x555555, 0x66aaff,
-		0xff6600, 0xff9988, 0xffff00, 0xffffff,
-	};
-	
+    };
+    private int[] doubleHiresPalette;
+    private static final int[] doubleHiresPaletteColor = {
+        0x000000, 0x000099, 0x007722, 0x2222ff,
+        0x885500, 0xaaaaaa, 0x11dd00, 0x44ff99,
+        0xdd0033, 0xdd22dd, 0x555555, 0x66aaff,
+        0xff6600, 0xff9988, 0xffff00, 0xffffff,
+    };
+
     // Thread stuff
-	private boolean isPaused = true;
-	private Thread thread;
+    private boolean isPaused = true;
+    private Thread thread;
 
     /**
      * AppleDisplay class constructor
-     * 
+     *
      * @param apple The EmAppleII instance
      */
     public AppleDisplay(EmAppleII apple) {
-		this.apple = apple;
-		
-		// Create display image
+        this.apple = apple;
+
+        // Create display image
         displayImageBuffer = new int[DISPLAY_SIZE_X * DISPLAY_SIZE_Y];
 
-		// Character maps
-		precalcCharMaps();
+        // Character maps
+        precalcCharMaps();
 
-		// Hires
-		precalcHiresEvenEddToWord();
+        // Hires
+        precalcHiresEvenEddToWord();
 
-		// Set parameters
-		setScale(1.0f);
-		setRefreshRate(10);
-		setColorMode(COLORMODE_GREEN);
-		requestRefresh();
-	}
-
-	/**
-	 * Set scale
-	 */
-	public void setScale(float value) {
-		if (value <= 0.0f) {
-			return;
-		}
-			
-		displayScale = value;
-		isPrecalcRequested = true;
-    }
-	
-	/**
-	 * Get scale
-	 */
-	public float getScale() {
-		return displayScale;
-    }
-	
-	/**
-	 * Set refresh rate
-	 *
-	 * @param	value	Display refresh rate in mHz
-	 */
-	public void setRefreshRate(int value) {
-		if (value <= 0.0f) {
-			return;
-		}
-			
-		this.refreshRate = value;
-		refreshInterval = (int) (1000.0 / value);
-    }
-	
-	/**
-	 * Get refresh rate
-	 */
-	public int getRefreshRate() {
-		return refreshRate;
-    }
-	
-	/**
-	 * Set color mode
-	 */
-	public void setColorMode(int value) {
-		colorMode = value;
-		isPrecalcRequested = true;
-    }
-	
-	/**
-	 * Get color mode
-	 */
-	public int getColorMode() {
-		return colorMode;
-    }
-	
-	/**
-	 * Set paused
-	 */
-	public void setPaused(boolean value) {
-		if (isPaused == value) {
-			return;
-		}
-
-		isPaused = value;
-		if (isPaused) {
-			try {
-				thread.join(1000);
-			} catch (InterruptedException e) {
-			}
-			apple.view.repaint();
-		} else {
-			isRefreshRequested = true;
-			thread = new Thread(this);
-			thread.start();
-		}
-    }
-	
-	/**
-	 * Get paused
-	 */
-	public boolean isPaused() {
-		return isPaused;
+        // Set parameters
+        setScale(1.0f);
+        setRefreshRate(10);
+        setColorMode(COLORMODE_GREEN);
+        requestRefresh();
     }
 
-	public void requestRefresh() {
+    /**
+     * Set scale
+     */
+    public void setScale(float value) {
+        if (value <= 0.0f) {
+            return;
+        }
+
+        displayScale = value;
+        isPrecalcRequested = true;
+    }
+
+    /**
+     * Get scale
+     */
+    public float getScale() {
+        return displayScale;
+    }
+
+    /**
+     * Set refresh rate
+     *
+     * @param    value    Display refresh rate in mHz
+     */
+    public void setRefreshRate(int value) {
+        if (value <= 0.0f) {
+            return;
+        }
+
+        this.refreshRate = value;
+        refreshInterval = (int) (1000.0 / value);
+    }
+
+    /**
+     * Get refresh rate
+     */
+    public int getRefreshRate() {
+        return refreshRate;
+    }
+
+    /**
+     * Set color mode
+     */
+    public void setColorMode(int value) {
+        colorMode = value;
+        isPrecalcRequested = true;
+    }
+
+    /**
+     * Get color mode
+     */
+    public int getColorMode() {
+        return colorMode;
+    }
+
+    /**
+     * Set paused
+     */
+    public void setPaused(boolean value) {
+        if (isPaused == value) {
+            return;
+        }
+
+        isPaused = value;
+        if (isPaused) {
+            try {
+                thread.join(1000);
+            } catch (InterruptedException e) {
+            }
+            apple.view.repaint();
+        } else {
+            isRefreshRequested = true;
+            thread = new Thread(this);
+            thread.start();
+        }
+    }
+
+    /**
+     * Get paused
+     */
+    public boolean isPaused() {
+        return isPaused;
+    }
+
+    public void requestRefresh() {
         isRefreshRequested = true;
-	}
+    }
 
-	/**
- 	 * Step instruction in debug mode
-	 */
-	public String getStatInfo() {
-		StringBuffer statInfo = new StringBuffer();
-		long refreshRateCurrent;
+    /**
+      * Step instruction in debug mode
+     */
+    public String getStatInfo() {
+        StringBuffer statInfo = new StringBuffer();
+        long refreshRateCurrent;
 
-		// Calculate effective CPU speed
-		if (refreshDelayPerSecond > 1000) {
-			refreshRateCurrent = refreshRate * 1000 / refreshDelayPerSecond;
-		} else {
-			refreshRateCurrent = refreshRate;
-		}
+        // Calculate effective CPU speed
+        if (refreshDelayPerSecond > 1000) {
+            refreshRateCurrent = refreshRate * 1000 / refreshDelayPerSecond;
+        } else {
+            refreshRateCurrent = refreshRate;
+        }
 
-		// Return FPS
-		statInfo.append(" FPS=").append(refreshRateCurrent).append(" [").append(refreshDelayPerSecond).append(" ms/s]\n");
-		statInfo.append(" GM=").append(graphicsMode).append("\n");
+        // Return FPS
+        statInfo.append(" FPS=").append(refreshRateCurrent).append(" [").append(refreshDelayPerSecond).append(" ms/s]\n");
+        statInfo.append(" GM=").append(graphicsMode).append("\n");
 
-		statInfo.append(" ").append((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / 1024L).append("KB/").append(Runtime.getRuntime().totalMemory() / 1024L).append("KB");
+        statInfo.append(" ").append((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / 1024L).append("KB/").append(Runtime.getRuntime().totalMemory() / 1024L).append("KB");
 
-		return statInfo.toString();
-	}
+        return statInfo.toString();
+    }
 
-	/**
-	 * Display refresh thread
-	 */
+    /**
+     * Display refresh thread
+     */
     public void run() {
-		try {
-			while (!isPaused) {
-				long refreshStart = System.currentTimeMillis();
-				long refreshDelay;
+        try {
+            while (!isPaused) {
+                long refreshStart = System.currentTimeMillis();
+                long refreshDelay;
 
-				refreshDisplay();
+                refreshDisplay();
 
-				refreshDelay = System.currentTimeMillis() - refreshStart;
+                refreshDelay = System.currentTimeMillis() - refreshStart;
 
-				refreshDelayCumulative += refreshDelay;
-				refreshCycle++;
-				if (refreshCycle >= refreshRate) {
-					refreshDelayPerSecond = refreshDelayCumulative;
-					refreshDelayCumulative = refreshCycle = 0;
-				}
+                refreshDelayCumulative += refreshDelay;
+                refreshCycle++;
+                if (refreshCycle >= refreshRate) {
+                    refreshDelayPerSecond = refreshDelayCumulative;
+                    refreshDelayCumulative = refreshCycle = 0;
+                }
 
-				if (refreshDelay < refreshInterval) {
-					Thread.sleep(refreshInterval - refreshDelay);
-				}
-			}
-		} catch (Throwable e) {
+                if (refreshDelay < refreshInterval) {
+                    Thread.sleep(refreshInterval - refreshDelay);
+                }
+            }
+        } catch (Throwable e) {
 apple.view.debug(e);
 apple.view.repaint();
-		}
-	}
-	
-	/**
-	 * Display refresh
-	 */
-	private void refreshDisplay() {
-		boolean isCharsetUpdateRequested = false;
-		boolean isSetDirtyRequested = false;
-		boolean isSetHiresDirtyRequested = false;
-		boolean isRenderRequested = false;
+        }
+    }
 
-		// Precalculation
-		if (isPrecalcRequested) {
-			isPrecalcRequested = false;
-			precalcDisplay();
-			graphicsMode = -1;
-		}
+    /**
+     * Display refresh
+     */
+    private void refreshDisplay() {
+        boolean isCharsetUpdateRequested = false;
+        boolean isSetDirtyRequested = false;
+        boolean isSetHiresDirtyRequested = false;
+        boolean isRenderRequested = false;
 
-		// Repaint if graphics mode changes
-		if (graphicsMode != apple.graphicsMode) {
-			graphicsMode = apple.graphicsMode;
-			isCharsetUpdateRequested = true;
-			isSetHiresDirtyRequested = true;
-		}
+        // Precalculation
+        if (isPrecalcRequested) {
+            isPrecalcRequested = false;
+            precalcDisplay();
+            graphicsMode = -1;
+        }
 
-		// Periodic refresh
-		if (charMapFlashCycle <= 0) {
-			charMapFlashCycle = refreshRate / 4 - 1;
-			isCharMapFlash = !isCharMapFlash;
-			isCharsetUpdateRequested = true;
-		} else {
-			charMapFlashCycle--;
-		}
+        // Repaint if graphics mode changes
+        if (graphicsMode != apple.graphicsMode) {
+            graphicsMode = apple.graphicsMode;
+            isCharsetUpdateRequested = true;
+            isSetHiresDirtyRequested = true;
+        }
 
-		// Some internal variables
-		boolean isSomeText = ((graphicsMode & (EmAppleII.GR_TEXT | EmAppleII.GR_MIXMODE)) != 0);
-		boolean isSomeLores = ((graphicsMode & (EmAppleII.GR_TEXT | EmAppleII.GR_HIRES)) == 0);
-		boolean isSomeHires = ((graphicsMode & (EmAppleII.GR_TEXT | EmAppleII.GR_HIRES)) == EmAppleII.GR_HIRES);
+        // Periodic refresh
+        if (charMapFlashCycle <= 0) {
+            charMapFlashCycle = refreshRate / 4 - 1;
+            isCharMapFlash = !isCharMapFlash;
+            isCharsetUpdateRequested = true;
+        } else {
+            charMapFlashCycle--;
+        }
 
-		boolean isMixedMode = ((graphicsMode & (EmAppleII.GR_TEXT | EmAppleII.GR_MIXMODE)) == EmAppleII.GR_MIXMODE);
-		boolean isPage2 = ((graphicsMode & (EmAppleII.GR_80STORE | EmAppleII.GR_PAGE2)) == EmAppleII.GR_PAGE2);
-		boolean isAltChar = ((graphicsMode & EmAppleII.GR_ALTCHAR) != 0);
-		boolean isDoubleTextMode = ((graphicsMode & EmAppleII.GR_80CHAR) == EmAppleII.GR_80CHAR);
-		boolean isDoubleGraphicsMode = ((graphicsMode & (EmAppleII.GR_80CHAR | EmAppleII.GR_DHIRES)) == (EmAppleII.GR_80CHAR | EmAppleII.GR_DHIRES));
+        // Some internal variables
+        boolean isSomeText = ((graphicsMode & (EmAppleII.GR_TEXT | EmAppleII.GR_MIXMODE)) != 0);
+        boolean isSomeLores = ((graphicsMode & (EmAppleII.GR_TEXT | EmAppleII.GR_HIRES)) == 0);
+        boolean isSomeHires = ((graphicsMode & (EmAppleII.GR_TEXT | EmAppleII.GR_HIRES)) == EmAppleII.GR_HIRES);
 
-		int baseAddressText = isPage2 ? EmAppleII.MEM_MAIN_RAM2 : EmAppleII.MEM_MAIN_TEXT;
-		int baseAddressHires = isPage2 ? EmAppleII.MEM_MAIN_RAM3 : EmAppleII.MEM_MAIN_HIRES;
+        boolean isMixedMode = ((graphicsMode & (EmAppleII.GR_TEXT | EmAppleII.GR_MIXMODE)) == EmAppleII.GR_MIXMODE);
+        boolean isPage2 = ((graphicsMode & (EmAppleII.GR_80STORE | EmAppleII.GR_PAGE2)) == EmAppleII.GR_PAGE2);
+        boolean isAltChar = ((graphicsMode & EmAppleII.GR_ALTCHAR) != 0);
+        boolean isDoubleTextMode = ((graphicsMode & EmAppleII.GR_80CHAR) == EmAppleII.GR_80CHAR);
+        boolean isDoubleGraphicsMode = ((graphicsMode & (EmAppleII.GR_80CHAR | EmAppleII.GR_DHIRES)) == (EmAppleII.GR_80CHAR | EmAppleII.GR_DHIRES));
 
-		// Set char map
-		if (isCharsetUpdateRequested) {
-			if (isAltChar) {
-				setCharMap(CHARMAP_ALT);
-			} else if (isCharMapFlash) {
-				setCharMap(CHARMAP_FLASH);
-			} else {
-				setCharMap(CHARMAP_NORMAL);
-			}
+        int baseAddressText = isPage2 ? EmAppleII.MEM_MAIN_RAM2 : EmAppleII.MEM_MAIN_TEXT;
+        int baseAddressHires = isPage2 ? EmAppleII.MEM_MAIN_RAM3 : EmAppleII.MEM_MAIN_HIRES;
 
-			isSetDirtyRequested = true;
-			isRefreshRequested = true;
-		}
-		
-		// Refresh dirty buffers?
-		if (isSetDirtyRequested) {
-			if (isSomeText || isSomeLores) {
-				setTextBufferDirty(baseAddressText);
-			}
+        // Set char map
+        if (isCharsetUpdateRequested) {
+            if (isAltChar) {
+                setCharMap(CHARMAP_ALT);
+            } else if (isCharMapFlash) {
+                setCharMap(CHARMAP_FLASH);
+            } else {
+                setCharMap(CHARMAP_NORMAL);
+            }
 
-			if (isSetHiresDirtyRequested && isSomeHires) {
-				setHiresBufferDirty(baseAddressHires);
-			}
+            isSetDirtyRequested = true;
+            isRefreshRequested = true;
+        }
 
-			isRenderRequested = true;
-		} else {
-			if ((isSomeText || isSomeLores) && isTextBufferDirty(baseAddressText)) {
-				isRenderRequested = true;
-			}
+        // Refresh dirty buffers?
+        if (isSetDirtyRequested) {
+            if (isSomeText || isSomeLores) {
+                setTextBufferDirty(baseAddressText);
+            }
 
-			if (isSomeHires && isHiresBufferDirty(baseAddressHires)) {
-				isRenderRequested = true;
-			}
-		}
+            if (isSetHiresDirtyRequested && isSomeHires) {
+                setHiresBufferDirty(baseAddressHires);
+            }
 
-		// Draw
-		if (isRenderRequested) {
-			if (isSomeText) {
-				if (isDoubleTextMode) {
-					renderDoubleText(baseAddressText, isMixedMode);
-				} else {
-					renderText(baseAddressText, isMixedMode);
-				}
-			}
-			
-			if (isSomeHires) {
-				if (isDoubleGraphicsMode) {
-					renderDoubleHires(baseAddressHires, isMixedMode);
-				} else {
-					renderHires(baseAddressHires, isMixedMode);
-				}
-			} else if (isSomeLores) {
-				if (isDoubleGraphicsMode) {
-					renderDoubleLores(baseAddressText, isMixedMode);
-				} else {
-					renderLores(baseAddressText, isMixedMode);
-				}
-			}
+            isRenderRequested = true;
+        } else {
+            if ((isSomeText || isSomeLores) && isTextBufferDirty(baseAddressText)) {
+                isRenderRequested = true;
+            }
 
-			isRefreshRequested = true;
-		}
+            if (isSomeHires && isHiresBufferDirty(baseAddressHires)) {
+                isRenderRequested = true;
+            }
+        }
+
+        // Draw
+        if (isRenderRequested) {
+            if (isSomeText) {
+                if (isDoubleTextMode) {
+                    renderDoubleText(baseAddressText, isMixedMode);
+                } else {
+                    renderText(baseAddressText, isMixedMode);
+                }
+            }
+
+            if (isSomeHires) {
+                if (isDoubleGraphicsMode) {
+                    renderDoubleHires(baseAddressHires, isMixedMode);
+                } else {
+                    renderHires(baseAddressHires, isMixedMode);
+                }
+            } else if (isSomeLores) {
+                if (isDoubleGraphicsMode) {
+                    renderDoubleLores(baseAddressText, isMixedMode);
+                } else {
+                    renderLores(baseAddressText, isMixedMode);
+                }
+            }
+
+            isRefreshRequested = true;
+        }
 
         if (isRefreshRequested) {
-			isRefreshRequested = false;
-			apple.view.repaint();
-		}
-	}
+            isRefreshRequested = false;
+            apple.view.repaint();
+        }
+    }
 
-	/**
-	 * Set text buffer dirty
-	 */
-	private void setTextBufferDirty(int baseAddress) {
-		// Update dirty
-		int addressStart = baseAddress >> 7;
-		int addressEnd = addressStart + 8;
-		for (int address = addressStart; address < addressEnd; address++) {
-			graphicsDirty[address] = true;
-			apple.graphicsDirty[address] = false;
-		}
-	}
+    /**
+     * Set text buffer dirty
+     */
+    private void setTextBufferDirty(int baseAddress) {
+        // Update dirty
+        int addressStart = baseAddress >> 7;
+        int addressEnd = addressStart + 8;
+        for (int address = addressStart; address < addressEnd; address++) {
+            graphicsDirty[address] = true;
+            apple.graphicsDirty[address] = false;
+        }
+    }
 
-	/**
-	 * Set hires buffer dirty
-	 */
-	private void setHiresBufferDirty(int baseAddress) {
-		// Update dirty
-		int addressStart = baseAddress >> 7;
-		int addressEnd = addressStart + 8;
-		for (int address = addressStart; address < addressEnd; address++) {
-			graphicsDirty[address] = true;
-			apple.graphicsDirty[address + (0x0000 >> 7)] = false;
-			apple.graphicsDirty[address + (0x0400 >> 7)] = false;
-			apple.graphicsDirty[address + (0x0800 >> 7)] = false;
-			apple.graphicsDirty[address + (0x0c00 >> 7)] = false;
-			apple.graphicsDirty[address + (0x1000 >> 7)] = false;
-			apple.graphicsDirty[address + (0x1400 >> 7)] = false;
-			apple.graphicsDirty[address + (0x1800 >> 7)] = false;
-			apple.graphicsDirty[address + (0x1c00 >> 7)] = false;
-		}
-	}
+    /**
+     * Set hires buffer dirty
+     */
+    private void setHiresBufferDirty(int baseAddress) {
+        // Update dirty
+        int addressStart = baseAddress >> 7;
+        int addressEnd = addressStart + 8;
+        for (int address = addressStart; address < addressEnd; address++) {
+            graphicsDirty[address] = true;
+            apple.graphicsDirty[address + (0x0000 >> 7)] = false;
+            apple.graphicsDirty[address + (0x0400 >> 7)] = false;
+            apple.graphicsDirty[address + (0x0800 >> 7)] = false;
+            apple.graphicsDirty[address + (0x0c00 >> 7)] = false;
+            apple.graphicsDirty[address + (0x1000 >> 7)] = false;
+            apple.graphicsDirty[address + (0x1400 >> 7)] = false;
+            apple.graphicsDirty[address + (0x1800 >> 7)] = false;
+            apple.graphicsDirty[address + (0x1c00 >> 7)] = false;
+        }
+    }
 
-	/**
-	 * Is text buffer dirty?
-	 */
-	private boolean isTextBufferDirty(int baseAddress) {
-		boolean isDirty = false;
+    /**
+     * Is text buffer dirty?
+     */
+    private boolean isTextBufferDirty(int baseAddress) {
+        boolean isDirty = false;
 
-		// Update dirty
-		int addressStart = baseAddress >> 7;
-		int addressEnd = addressStart + 8;
-		for (int address = addressStart; address < addressEnd; address++) {
-			graphicsDirty[address] = apple.graphicsDirty[address];
-			apple.graphicsDirty[address] = false;
-			if (graphicsDirty[address]) {
-				isDirty = true;
-			}
-		}
-		
-		return isDirty;
-	}
+        // Update dirty
+        int addressStart = baseAddress >> 7;
+        int addressEnd = addressStart + 8;
+        for (int address = addressStart; address < addressEnd; address++) {
+            graphicsDirty[address] = apple.graphicsDirty[address];
+            apple.graphicsDirty[address] = false;
+            if (graphicsDirty[address]) {
+                isDirty = true;
+            }
+        }
 
-	/**
-	 * Is hires buffer dirty?
-	 */
-	private boolean isHiresBufferDirty(int baseAddress) {
-		boolean isDirty = false;
+        return isDirty;
+    }
 
-		// Update dirty
-		int addressStart = baseAddress >> 7;
-		int addressEnd = addressStart + 8;
-		for (int address = addressStart; address < addressEnd; address++) {
-			graphicsDirty[address] =
-				apple.graphicsDirty[address + (0x0000 >> 7)] || 
-				apple.graphicsDirty[address + (0x0400 >> 7)] ||
-				apple.graphicsDirty[address + (0x0800 >> 7)] || 
-				apple.graphicsDirty[address + (0x0c00 >> 7)] || 
-				apple.graphicsDirty[address + (0x1000 >> 7)] || 
-				apple.graphicsDirty[address + (0x1400 >> 7)] ||
-				apple.graphicsDirty[address + (0x1800 >> 7)] || 
-				apple.graphicsDirty[address + (0x1c00 >> 7)];
-			apple.graphicsDirty[address + (0x0000 >> 7)] = false;
-			apple.graphicsDirty[address + (0x0400 >> 7)] = false;
-			apple.graphicsDirty[address + (0x0800 >> 7)] = false;
-			apple.graphicsDirty[address + (0x0c00 >> 7)] = false;
-			apple.graphicsDirty[address + (0x1000 >> 7)] = false;
-			apple.graphicsDirty[address + (0x1400 >> 7)] = false;
-			apple.graphicsDirty[address + (0x1800 >> 7)] = false;
-			apple.graphicsDirty[address + (0x1c00 >> 7)] = false;
-			if (graphicsDirty[address]) {
-				isDirty = true;
-			}
-		}
-		
-		return isDirty;
-	}
-	
-	/**
-	 * Display precalculation
-	 */
-	private void precalcDisplay() {
-		// Display scaled size
-	    apple.view.setDisplayScaledSizeX((int) (DISPLAY_SIZE_X * displayScale / 2));
-	    apple.view.setDisplayScaledSizeY((int) (DISPLAY_SIZE_Y * displayScale));
+    /**
+     * Is hires buffer dirty?
+     */
+    private boolean isHiresBufferDirty(int baseAddress) {
+        boolean isDirty = false;
 
-		// Prepare display palette
-		setDisplayPalette();
+        // Update dirty
+        int addressStart = baseAddress >> 7;
+        int addressEnd = addressStart + 8;
+        for (int address = addressStart; address < addressEnd; address++) {
+            graphicsDirty[address] =
+                apple.graphicsDirty[address + (0x0000 >> 7)] ||
+                apple.graphicsDirty[address + (0x0400 >> 7)] ||
+                apple.graphicsDirty[address + (0x0800 >> 7)] ||
+                apple.graphicsDirty[address + (0x0c00 >> 7)] ||
+                apple.graphicsDirty[address + (0x1000 >> 7)] ||
+                apple.graphicsDirty[address + (0x1400 >> 7)] ||
+                apple.graphicsDirty[address + (0x1800 >> 7)] ||
+                apple.graphicsDirty[address + (0x1c00 >> 7)];
+            apple.graphicsDirty[address + (0x0000 >> 7)] = false;
+            apple.graphicsDirty[address + (0x0400 >> 7)] = false;
+            apple.graphicsDirty[address + (0x0800 >> 7)] = false;
+            apple.graphicsDirty[address + (0x0c00 >> 7)] = false;
+            apple.graphicsDirty[address + (0x1000 >> 7)] = false;
+            apple.graphicsDirty[address + (0x1400 >> 7)] = false;
+            apple.graphicsDirty[address + (0x1800 >> 7)] = false;
+            apple.graphicsDirty[address + (0x1c00 >> 7)] = false;
+            if (graphicsDirty[address]) {
+                isDirty = true;
+            }
+        }
 
-		// Prepare character set
-		loadCharSet();
+        return isDirty;
+    }
 
-		// Prepare hires graphics
-		precalcHiresLookup();
-	}
+    /**
+     * Display precalculation
+     */
+    private void precalcDisplay() {
+        // Display scaled size
+        apple.view.setDisplayScaledSizeX((int) (DISPLAY_SIZE_X * displayScale / 2));
+        apple.view.setDisplayScaledSizeY((int) (DISPLAY_SIZE_Y * displayScale));
+
+        // Prepare display palette
+        setDisplayPalette();
+
+        // Prepare character set
+        loadCharSet();
+
+        // Prepare hires graphics
+        precalcHiresLookup();
+    }
 
     private static final int CHARSET_SOURCE_CHAR_COUNT = 128;
     private static final int CHARSET_SOURCE_SIZE_X = CHARSET_SOURCE_CHAR_COUNT * CHARSET_CHAR_SIZE_X;
     private static final int CHARSET_SOURCE_SIZE_Y = CHARSET_CHAR_SIZE_Y;
 
     /**
-	 * Precalculate charSet
-	 */
-	private void loadCharSet() {
-		int charSetOffset = 0;
+     * Precalculate charSet
+     */
+    private void loadCharSet() {
+        int charSetOffset = 0;
 
-		// Get RGB image
-		Object resource = apple.view.getCharSet(charSet, CHARSET_SOURCE_SIZE_X, CHARSET_SOURCE_SIZE_Y, CHARSET_SIZE_X);
+        // Get RGB image
+        Object resource = apple.view.getCharSet(charSet, CHARSET_SOURCE_SIZE_X, CHARSET_SOURCE_SIZE_Y, CHARSET_SIZE_X);
 
-		// Duplicate and invert
-		for (int charSetPosY = 0; charSetPosY < CHARSET_SIZE_Y; charSetPosY++) {
-			for (int charSetPosX = 0; charSetPosX < CHARSET_SOURCE_SIZE_X; charSetPosX++) {
-				charSet[charSetOffset + CHARSET_SOURCE_SIZE_X + charSetPosX] = 
-					charSet[charSetOffset + charSetPosX] ^ 0xffffff;
-			}
-			charSetOffset += CHARSET_SIZE_X;
-		}
-		
-		// Colorize
-		for (charSetOffset = 0; charSetOffset < (CHARSET_SIZE_X * CHARSET_SIZE_Y); charSetOffset++) {
-			charSet[charSetOffset] &= (displayPalette[0xf] | 0xff000000);
-		}
+        // Duplicate and invert
+        for (int charSetPosY = 0; charSetPosY < CHARSET_SIZE_Y; charSetPosY++) {
+            for (int charSetPosX = 0; charSetPosX < CHARSET_SOURCE_SIZE_X; charSetPosX++) {
+                charSet[charSetOffset + CHARSET_SOURCE_SIZE_X + charSetPosX] =
+                    charSet[charSetOffset + charSetPosX] ^ 0xffffff;
+            }
+            charSetOffset += CHARSET_SIZE_X;
+        }
+
+        // Colorize
+        for (charSetOffset = 0; charSetOffset < (CHARSET_SIZE_X * CHARSET_SIZE_Y); charSetOffset++) {
+            charSet[charSetOffset] &= (displayPalette[0xf] | 0xff000000);
+        }
 
 //apple.view.debug("here");
-		apple.view.flushCharSet(resource);
-	}
+        apple.view.flushCharSet(resource);
+    }
 
-	/**
-	 * Precalculate char map
-	 */
-	private void precalcCharMaps() {
-		for (int index = 0; index < 3; index++) {
-			for (int character = 0; character < 0x100; character++) {
-				charMaps[index][character] = charMapLookup[index][character >> 5] + (character & 0x1f);
-			}
-		}
-	}
+    /**
+     * Precalculate char map
+     */
+    private void precalcCharMaps() {
+        for (int index = 0; index < 3; index++) {
+            for (int character = 0; character < 0x100; character++) {
+                charMaps[index][character] = charMapLookup[index][character >> 5] + (character & 0x1f);
+            }
+        }
+    }
 
-	/**
-	 * Set char map
-	 */
-	private void setCharMap(int value) {
-		charMap = charMaps[value];
-	}
+    /**
+     * Set char map
+     */
+    private void setCharMap(int value) {
+        charMap = charMaps[value];
+    }
 
-	/**
-	 * Set lores palette
-	 */
-	private void setDisplayPalette() {
-		displayPalette = (colorMode == COLORMODE_COLOR) ? displayPaletteColor : displayPaletteGreen;
-		doubleHiresPalette = (colorMode == COLORMODE_COLOR) ? doubleHiresPaletteColor : displayPaletteGreen;
-	}
+    /**
+     * Set lores palette
+     */
+    private void setDisplayPalette() {
+        displayPalette = (colorMode == COLORMODE_COLOR) ? displayPaletteColor : displayPaletteGreen;
+        doubleHiresPalette = (colorMode == COLORMODE_COLOR) ? doubleHiresPaletteColor : displayPaletteGreen;
+    }
 
-	/**
-	 * Precalculate hires even odd to word
-	 */
-	private void precalcHiresEvenEddToWord() {
-		for (int value = 0; value < 0x200; value++) {
-			hiresEvenOddToWord[value] = 
-				((value & 0x01) << 0) |
-				((value & 0x01) << 1) | 
-				((value & 0x02) << 1) |
-				((value & 0x02) << 2) | 
-				((value & 0x04) << 2) |
-				((value & 0x04) << 3) | 
-				((value & 0x08) << 3) |
-				((value & 0x08) << 4) | 
-				((value & 0x10) << 4) |
-				((value & 0x10) << 5) | 
-				((value & 0x20) << 5) |
-				((value & 0x20) << 6) | 
-				((value & 0x40) << 6) |
-				((value & 0x40) << 7);
+    /**
+     * Precalculate hires even odd to word
+     */
+    private void precalcHiresEvenEddToWord() {
+        for (int value = 0; value < 0x200; value++) {
+            hiresEvenOddToWord[value] =
+                ((value & 0x01) << 0) |
+                ((value & 0x01) << 1) |
+                ((value & 0x02) << 1) |
+                ((value & 0x02) << 2) |
+                ((value & 0x04) << 2) |
+                ((value & 0x04) << 3) |
+                ((value & 0x08) << 3) |
+                ((value & 0x08) << 4) |
+                ((value & 0x10) << 4) |
+                ((value & 0x10) << 5) |
+                ((value & 0x20) << 5) |
+                ((value & 0x20) << 6) |
+                ((value & 0x40) << 6) |
+                ((value & 0x40) << 7);
 
-			if ((value & 0x80) != 0) {
-				hiresEvenOddToWord[value] <<= 1;
-				hiresEvenOddToWord[value] |= ((value & 0x100) >> 8);
-			}
-		}
-	}
+            if ((value & 0x80) != 0) {
+                hiresEvenOddToWord[value] <<= 1;
+                hiresEvenOddToWord[value] |= ((value & 0x100) >> 8);
+            }
+        }
+    }
 
-	/**
-	 * Precalculate hires
-	 */
-	private void precalcHiresLookup() {
-		if (colorMode == COLORMODE_COLOR) {
-			for (int value = 0; value < 0x100; value++) {
-				hiresLookup[value] = hiresLookupColor[((value << 6) & 0xff) | (value >> 2)];
-			}
-		} else {
-			for (int value = 0; value < 0x100; value++) {
-				hiresLookup[value] = 
-					(((value & 0x04) != 0) ? 0x000f : 0) | 
-					(((value & 0x08) != 0) ? 0x00f0 : 0) | 
-					(((value & 0x10) != 0) ? 0x0f00 : 0) | 
-					(((value & 0x20) != 0) ? 0xf000 : 0);
-			}
-		}
-	}
-	
-	/**
-	 * Render text canvas
-	 */
-	private final void renderTextScanLine(int destOffset, int sourceOffset) {
-		displayImageBuffer[destOffset + 0] = displayImageBuffer[destOffset + 1] = charSet[sourceOffset];
-		displayImageBuffer[destOffset + 2] = displayImageBuffer[destOffset + 3] = charSet[sourceOffset + 1];
-		displayImageBuffer[destOffset + 4] = displayImageBuffer[destOffset + 5] = charSet[sourceOffset + 2];
-		displayImageBuffer[destOffset + 6] = displayImageBuffer[destOffset + 7] = charSet[sourceOffset + 3];
-		displayImageBuffer[destOffset + 8] = displayImageBuffer[destOffset + 9] = charSet[sourceOffset + 4];
-		displayImageBuffer[destOffset + 10] = displayImageBuffer[destOffset + 11] = charSet[sourceOffset + 5];
-		displayImageBuffer[destOffset + 12] = displayImageBuffer[destOffset + 13] = charSet[sourceOffset + 6];
-	}
+    /**
+     * Precalculate hires
+     */
+    private void precalcHiresLookup() {
+        if (colorMode == COLORMODE_COLOR) {
+            for (int value = 0; value < 0x100; value++) {
+                hiresLookup[value] = hiresLookupColor[((value << 6) & 0xff) | (value >> 2)];
+            }
+        } else {
+            for (int value = 0; value < 0x100; value++) {
+                hiresLookup[value] =
+                    (((value & 0x04) != 0) ? 0x000f : 0) |
+                    (((value & 0x08) != 0) ? 0x00f0 : 0) |
+                    (((value & 0x10) != 0) ? 0x0f00 : 0) |
+                    (((value & 0x20) != 0) ? 0xf000 : 0);
+            }
+        }
+    }
 
-	private final void renderTextCharacter(int destOffset, int sourceOffset) {
-		renderTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderTextScanLine(destOffset, sourceOffset);
-	}
+    /**
+     * Render text canvas
+     */
+    private final void renderTextScanLine(int destOffset, int sourceOffset) {
+        displayImageBuffer[destOffset + 0] = displayImageBuffer[destOffset + 1] = charSet[sourceOffset];
+        displayImageBuffer[destOffset + 2] = displayImageBuffer[destOffset + 3] = charSet[sourceOffset + 1];
+        displayImageBuffer[destOffset + 4] = displayImageBuffer[destOffset + 5] = charSet[sourceOffset + 2];
+        displayImageBuffer[destOffset + 6] = displayImageBuffer[destOffset + 7] = charSet[sourceOffset + 3];
+        displayImageBuffer[destOffset + 8] = displayImageBuffer[destOffset + 9] = charSet[sourceOffset + 4];
+        displayImageBuffer[destOffset + 10] = displayImageBuffer[destOffset + 11] = charSet[sourceOffset + 5];
+        displayImageBuffer[destOffset + 12] = displayImageBuffer[destOffset + 13] = charSet[sourceOffset + 6];
+    }
 
-	private void renderText(int baseAddress, boolean isMixedMode) {
-		int screenCharY, screenCharYStart = isMixedMode ? 20 : 0;
-		int displayOffset;
-		int address, addressEnd, addressStart;
-		
-		displayOffset = screenCharYStart * DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
-		for (screenCharY = screenCharYStart; screenCharY < 24; screenCharY++) {
-			addressStart = baseAddress + textLineAddress[screenCharY];
-			
-			if (graphicsDirty[addressStart >> 7]) {
-				addressEnd = addressStart + 40;
-				
-				for (address = addressStart; address < addressEnd; address++) {
-					renderTextCharacter(displayOffset, charMap[apple.mem[address] & 0xff] << 3);
-					displayOffset += DISPLAY_CHAR_SIZE_X * 2;
-				}
-				displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
-			} else {
-				displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
-			}
-		}
-	}
-	
-	/**
-	 * Render double text canvas
-	 */
-	private final void renderDoubleTextScanLine(int destOffset, int sourceOffset) {
-		displayImageBuffer[destOffset + 0] = charSet[sourceOffset];
-		displayImageBuffer[destOffset + 1] = charSet[sourceOffset + 1];
-		displayImageBuffer[destOffset + 2] = charSet[sourceOffset + 2];
-		displayImageBuffer[destOffset + 3] = charSet[sourceOffset + 3];
-		displayImageBuffer[destOffset + 4] = charSet[sourceOffset + 4];
-		displayImageBuffer[destOffset + 5] = charSet[sourceOffset + 5];
-		displayImageBuffer[destOffset + 6] = charSet[sourceOffset + 6];
-	}
+    private final void renderTextCharacter(int destOffset, int sourceOffset) {
+        renderTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderTextScanLine(destOffset, sourceOffset);
+    }
 
-	private final void renderDoubleTextCharacter(int destOffset, int sourceOffset) {
-		renderDoubleTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderDoubleTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderDoubleTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderDoubleTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderDoubleTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderDoubleTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderDoubleTextScanLine(destOffset, sourceOffset);
-		destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
-		renderDoubleTextScanLine(destOffset, sourceOffset);
-	}
+    private void renderText(int baseAddress, boolean isMixedMode) {
+        int screenCharY, screenCharYStart = isMixedMode ? 20 : 0;
+        int displayOffset;
+        int address, addressEnd, addressStart;
 
-	private void renderDoubleText(int baseAddress, boolean isMixedMode) {
-		int screenCharY, screenCharYStart = isMixedMode ? 20 : 0;
-		int displayOffset;
-		int address, addressEnd, addressStart;
-		
-		displayOffset = screenCharYStart * DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
-		for (screenCharY = screenCharYStart; screenCharY < 24; screenCharY++) {
-			addressStart = baseAddress + textLineAddress[screenCharY];
-			
-			if (graphicsDirty[addressStart >> 7]) {
-				addressEnd = addressStart + 40;
-				
-				for (address = addressStart; address < addressEnd; address++) {
-					renderDoubleTextCharacter(displayOffset, charMap[apple.mem[address + 0x10000] & 0xff] << 3);
-					displayOffset += DISPLAY_CHAR_SIZE_X;
-					renderDoubleTextCharacter(displayOffset, charMap[apple.mem[address + 0x00000] & 0xff] << 3);
-					displayOffset += DISPLAY_CHAR_SIZE_X;
-				}
-				displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
-			} else {
-				displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
-			}
-		}
-	}
-		
-	/**
-	 * Render lores canvas
-	 */
-	private final void renderLoresScanLine(int destOffset, int color) {
-		displayImageBuffer[destOffset + 0] = color;
-		displayImageBuffer[destOffset + 1] = color;
-		displayImageBuffer[destOffset + 2] = color;
-		displayImageBuffer[destOffset + 3] = color;
-		displayImageBuffer[destOffset + 4] = color;
-		displayImageBuffer[destOffset + 5] = color;
-		displayImageBuffer[destOffset + 6] = color;
-	}
+        displayOffset = screenCharYStart * DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
+        for (screenCharY = screenCharYStart; screenCharY < 24; screenCharY++) {
+            addressStart = baseAddress + textLineAddress[screenCharY];
 
-	private final void renderLoresBlock(int destOffset, int colorTop, int colorBottom) {
-		renderLoresScanLine(destOffset, colorTop);
-		destOffset += DISPLAY_SIZE_X;
-		renderLoresScanLine(destOffset, colorTop);
-		destOffset += DISPLAY_SIZE_X;
-		renderLoresScanLine(destOffset, colorTop);
-		destOffset += DISPLAY_SIZE_X;
-		renderLoresScanLine(destOffset, colorTop);
-		destOffset += DISPLAY_SIZE_X;
-		renderLoresScanLine(destOffset, colorBottom);
-		destOffset += DISPLAY_SIZE_X;
-		renderLoresScanLine(destOffset, colorBottom);
-		destOffset += DISPLAY_SIZE_X;
-		renderLoresScanLine(destOffset, colorBottom);
-		destOffset += DISPLAY_SIZE_X;
-		renderLoresScanLine(destOffset, colorBottom);
-	}
+            if (graphicsDirty[addressStart >> 7]) {
+                addressEnd = addressStart + 40;
 
-	private void renderLores(int baseAddress, boolean isMixedMode) {
-		int screenCharY, screenCharYEnd = isMixedMode ? 20 : 24;
-		int displayOffset;
-		int address, addressEnd, addressStart;
-		
-		displayOffset = 0;
-		for (screenCharY = 0; screenCharY < screenCharYEnd; screenCharY++) {
-			addressStart = baseAddress + textLineAddress[screenCharY];
-			
-			if (graphicsDirty[addressStart >> 7]) {
-				addressEnd = addressStart + 40;
-				
-				for (address = addressStart; address < addressEnd; address++) {
-					renderLoresBlock(displayOffset, 
-						displayPalette[apple.mem[address] & 0xf], 
-						displayPalette[(apple.mem[address] & 0xf0) >> 4]);
-					displayOffset += DISPLAY_CHAR_SIZE_X;
-					renderLoresBlock(displayOffset, 
-						displayPalette[apple.mem[address] & 0xf], 
-						displayPalette[(apple.mem[address] & 0xf0) >> 4]);
-					displayOffset += DISPLAY_CHAR_SIZE_X;
-				}
-				displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
-			} else {
-				displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
-			}
-		}
-	}
+                for (address = addressStart; address < addressEnd; address++) {
+                    renderTextCharacter(displayOffset, charMap[apple.mem[address] & 0xff] << 3);
+                    displayOffset += DISPLAY_CHAR_SIZE_X * 2;
+                }
+                displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
+            } else {
+                displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
+            }
+        }
+    }
 
-	/**
-	 * Render double lores canvas
-	 */
-	private void renderDoubleLores(int baseAddress, boolean isMixedMode) {
-		int screenCharY, screenCharYEnd = isMixedMode ? 20 : 24;
-		int displayOffset;
-		int address, addressEnd, addressStart;
-		
-		displayOffset = 0;
-		for (screenCharY = 0; screenCharY < screenCharYEnd; screenCharY++) {
-			addressStart = baseAddress + textLineAddress[screenCharY];
-			
-			if (graphicsDirty[addressStart >> 7]) {
-				addressEnd = addressStart + 40;
-				
-				for (address = addressStart; address < addressEnd; address++) {
-					renderLoresBlock(displayOffset, 
-						displayPalette[apple.mem[address + 0x10000] & 0xf], 
-						displayPalette[(apple.mem[address + 0x10000] & 0xf0) >> 4]);
-					displayOffset += DISPLAY_CHAR_SIZE_X;
-					renderLoresBlock(displayOffset, 
-						displayPalette[apple.mem[address] & 0xf], 
-						displayPalette[(apple.mem[address] & 0xf0) >> 4]);
-					displayOffset += DISPLAY_CHAR_SIZE_X;
-				}
-				displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
-			} else {
-				displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
-			}
-		}
-	}
+    /**
+     * Render double text canvas
+     */
+    private final void renderDoubleTextScanLine(int destOffset, int sourceOffset) {
+        displayImageBuffer[destOffset + 0] = charSet[sourceOffset];
+        displayImageBuffer[destOffset + 1] = charSet[sourceOffset + 1];
+        displayImageBuffer[destOffset + 2] = charSet[sourceOffset + 2];
+        displayImageBuffer[destOffset + 3] = charSet[sourceOffset + 3];
+        displayImageBuffer[destOffset + 4] = charSet[sourceOffset + 4];
+        displayImageBuffer[destOffset + 5] = charSet[sourceOffset + 5];
+        displayImageBuffer[destOffset + 6] = charSet[sourceOffset + 6];
+    }
 
-	/**
-	 * Render hires canvas
-	 */
-	private final void renderHiresWord(int destOffset, int hiresNibble) {
-		displayImageBuffer[destOffset + 0] = displayPalette[(hiresNibble >> 0) & 0xf];
-		displayImageBuffer[destOffset + 1] = displayPalette[(hiresNibble >> 4) & 0xf];
-		displayImageBuffer[destOffset + 2] = displayPalette[(hiresNibble >> 8) & 0xf];
-		displayImageBuffer[destOffset + 3] = displayPalette[(hiresNibble >> 12) & 0xf];
-	}
+    private final void renderDoubleTextCharacter(int destOffset, int sourceOffset) {
+        renderDoubleTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderDoubleTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderDoubleTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderDoubleTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderDoubleTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderDoubleTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderDoubleTextScanLine(destOffset, sourceOffset);
+        destOffset += DISPLAY_SIZE_X; sourceOffset += CHARSET_SIZE_X;
+        renderDoubleTextScanLine(destOffset, sourceOffset);
+    }
 
-	private final void renderHiresScanLine(int destOffset, int hiresWord) {
-		renderHiresWord(destOffset + 0, hiresLookup[(hiresWord >> 0) & 0xff]);
-		renderHiresWord(destOffset + 4, hiresLookup[(hiresWord >> 4) & 0xff]);
-		renderHiresWord(destOffset + 8, hiresLookup[(hiresWord >> 8) & 0xff]);
-		renderHiresWord(destOffset + 12, hiresLookup[(hiresWord >> 12) & 0xff]);
-		renderHiresWord(destOffset + 16, hiresLookup[(hiresWord >> 16) & 0xff]);
-		renderHiresWord(destOffset + 20, hiresLookup[(hiresWord >> 20) & 0xff]);
-		renderHiresWord(destOffset + 24, hiresLookup[(hiresWord >> 24) & 0xff]);
-	}
+    private void renderDoubleText(int baseAddress, boolean isMixedMode) {
+        int screenCharY, screenCharYStart = isMixedMode ? 20 : 0;
+        int displayOffset;
+        int address, addressEnd, addressStart;
 
-	private final void renderHiresBlock(int destOffset) {
-		renderHiresScanLine(destOffset, hiresWord[0]); destOffset += DISPLAY_SIZE_X;
-		renderHiresScanLine(destOffset, hiresWord[1]); destOffset += DISPLAY_SIZE_X;
-		renderHiresScanLine(destOffset, hiresWord[2]); destOffset += DISPLAY_SIZE_X;
-		renderHiresScanLine(destOffset, hiresWord[3]); destOffset += DISPLAY_SIZE_X;
-		renderHiresScanLine(destOffset, hiresWord[4]); destOffset += DISPLAY_SIZE_X;
-		renderHiresScanLine(destOffset, hiresWord[5]); destOffset += DISPLAY_SIZE_X;
-		renderHiresScanLine(destOffset, hiresWord[6]); destOffset += DISPLAY_SIZE_X;
-		renderHiresScanLine(destOffset, hiresWord[7]);
-	}
+        displayOffset = screenCharYStart * DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
+        for (screenCharY = screenCharYStart; screenCharY < 24; screenCharY++) {
+            addressStart = baseAddress + textLineAddress[screenCharY];
 
-	private final void resetHiresWords() {
-		hiresWord[0] = 0;
-		hiresWord[1] = 0;
-		hiresWord[2] = 0;
-		hiresWord[3] = 0;
-		hiresWord[4] = 0;
-		hiresWord[5] = 0;
-		hiresWord[6] = 0;
-		hiresWord[7] = 0;
-	}
+            if (graphicsDirty[addressStart >> 7]) {
+                addressEnd = addressStart + 40;
 
-	private final void bufferHiresWords() {
-		hiresWord[0] = hiresWordNext[0];
-		hiresWord[1] = hiresWordNext[1];
-		hiresWord[2] = hiresWordNext[2];
-		hiresWord[3] = hiresWordNext[3];
-		hiresWord[4] = hiresWordNext[4];
-		hiresWord[5] = hiresWordNext[5];
-		hiresWord[6] = hiresWordNext[6];
-		hiresWord[7] = hiresWordNext[7];
-	}
+                for (address = addressStart; address < addressEnd; address++) {
+                    renderDoubleTextCharacter(displayOffset, charMap[apple.mem[address + 0x10000] & 0xff] << 3);
+                    displayOffset += DISPLAY_CHAR_SIZE_X;
+                    renderDoubleTextCharacter(displayOffset, charMap[apple.mem[address + 0x00000] & 0xff] << 3);
+                    displayOffset += DISPLAY_CHAR_SIZE_X;
+                }
+                displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
+            } else {
+                displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
+            }
+        }
+    }
 
-	private final void calcNextHiresWord(int hiresWordIndex, int byteEven, int byteOdd) {
-		hiresWordNext[hiresWordIndex] = hiresWord[hiresWordIndex] >> 28;
-		hiresWordNext[hiresWordIndex] |= 
-			hiresEvenOddToWord[(byteEven & 0xff) | ((hiresWordNext[hiresWordIndex] & 0x2) << 7)] << 2;
-		hiresWordNext[hiresWordIndex] |= 
-			hiresEvenOddToWord[(byteOdd & 0xff) | ((hiresWordNext[hiresWordIndex] & 0x8000) >> 7)] << 16;
-		hiresWord[hiresWordIndex] |= (hiresWordNext[hiresWordIndex] << 28);
-	}
+    /**
+     * Render lores canvas
+     */
+    private final void renderLoresScanLine(int destOffset, int color) {
+        displayImageBuffer[destOffset + 0] = color;
+        displayImageBuffer[destOffset + 1] = color;
+        displayImageBuffer[destOffset + 2] = color;
+        displayImageBuffer[destOffset + 3] = color;
+        displayImageBuffer[destOffset + 4] = color;
+        displayImageBuffer[destOffset + 5] = color;
+        displayImageBuffer[destOffset + 6] = color;
+    }
 
-	private final void calcNextHiresWords(int address) {
-		calcNextHiresWord(0, apple.mem[address + 0x00000], apple.mem[address + 0x00001]);
-		calcNextHiresWord(1, apple.mem[address + 0x00400], apple.mem[address + 0x00401]);
-		calcNextHiresWord(2, apple.mem[address + 0x00800], apple.mem[address + 0x00801]);
-		calcNextHiresWord(3, apple.mem[address + 0x00c00], apple.mem[address + 0x00c01]);
-		calcNextHiresWord(4, apple.mem[address + 0x01000], apple.mem[address + 0x01001]);
-		calcNextHiresWord(5, apple.mem[address + 0x01400], apple.mem[address + 0x01401]);
-		calcNextHiresWord(6, apple.mem[address + 0x01800], apple.mem[address + 0x01801]);
-		calcNextHiresWord(7, apple.mem[address + 0x01c00], apple.mem[address + 0x01c01]);
-	}
+    private final void renderLoresBlock(int destOffset, int colorTop, int colorBottom) {
+        renderLoresScanLine(destOffset, colorTop);
+        destOffset += DISPLAY_SIZE_X;
+        renderLoresScanLine(destOffset, colorTop);
+        destOffset += DISPLAY_SIZE_X;
+        renderLoresScanLine(destOffset, colorTop);
+        destOffset += DISPLAY_SIZE_X;
+        renderLoresScanLine(destOffset, colorTop);
+        destOffset += DISPLAY_SIZE_X;
+        renderLoresScanLine(destOffset, colorBottom);
+        destOffset += DISPLAY_SIZE_X;
+        renderLoresScanLine(destOffset, colorBottom);
+        destOffset += DISPLAY_SIZE_X;
+        renderLoresScanLine(destOffset, colorBottom);
+        destOffset += DISPLAY_SIZE_X;
+        renderLoresScanLine(destOffset, colorBottom);
+    }
 
-	private void renderHires(int baseAddress, boolean isMixedMode) {
-		int screenCharY, screenCharYEnd = isMixedMode ? 20 : 24;
-		int displayOffset;
-		int address, addressEnd, addressStart;
-		
-		displayOffset = 0;
-		for (screenCharY = 0; screenCharY < screenCharYEnd; screenCharY++) {
-			addressStart = baseAddress + textLineAddress[screenCharY];
-			
-			if (graphicsDirty[addressStart >> 7]) {
-				addressEnd = addressStart + 40;
+    private void renderLores(int baseAddress, boolean isMixedMode) {
+        int screenCharY, screenCharYEnd = isMixedMode ? 20 : 24;
+        int displayOffset;
+        int address, addressEnd, addressStart;
 
-				resetHiresWords();
-				calcNextHiresWords(addressStart);
-				for (address = (addressStart + 2); address < addressEnd; address += 2) {
-					bufferHiresWords();
-					calcNextHiresWords(address);
-					renderHiresBlock(displayOffset);
-					displayOffset += DISPLAY_CHAR_SIZE_X * 4;
-				}
-				bufferHiresWords();
-				renderHiresBlock(displayOffset);
-				displayOffset += DISPLAY_CHAR_SIZE_X * 4;
-				
-				displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
-			} else {
-				displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
-			}
-		}
-	}
+        displayOffset = 0;
+        for (screenCharY = 0; screenCharY < screenCharYEnd; screenCharY++) {
+            addressStart = baseAddress + textLineAddress[screenCharY];
 
-	/**
-	 * Render double hires canvas
-	 */
-	private final void renderDoubleHiresWord(int destOffset, int hiresNibble) {
-		displayImageBuffer[destOffset + 0] = doubleHiresPalette[(hiresNibble >> 0) & 0xf];
-		displayImageBuffer[destOffset + 1] = doubleHiresPalette[(hiresNibble >> 4) & 0xf];
-		displayImageBuffer[destOffset + 2] = doubleHiresPalette[(hiresNibble >> 8) & 0xf];
-		displayImageBuffer[destOffset + 3] = doubleHiresPalette[(hiresNibble >> 12) & 0xf];
-	}
+            if (graphicsDirty[addressStart >> 7]) {
+                addressEnd = addressStart + 40;
 
-	private final void renderDoubleHiresScanLine(int destOffset, int hiresWord) {
-		renderDoubleHiresWord(destOffset + 0, hiresLookup[(hiresWord >> 0) & 0xff]);
-		renderDoubleHiresWord(destOffset + 4, hiresLookup[(hiresWord >> 4) & 0xff]);
-		renderDoubleHiresWord(destOffset + 8, hiresLookup[(hiresWord >> 8) & 0xff]);
-		renderDoubleHiresWord(destOffset + 12, hiresLookup[(hiresWord >> 12) & 0xff]);
-		renderDoubleHiresWord(destOffset + 16, hiresLookup[(hiresWord >> 16) & 0xff]);
-		renderDoubleHiresWord(destOffset + 20, hiresLookup[(hiresWord >> 20) & 0xff]);
-		renderDoubleHiresWord(destOffset + 24, hiresLookup[(hiresWord >> 24) & 0xff]);
-	}
+                for (address = addressStart; address < addressEnd; address++) {
+                    renderLoresBlock(displayOffset,
+                        displayPalette[apple.mem[address] & 0xf],
+                        displayPalette[(apple.mem[address] & 0xf0) >> 4]);
+                    displayOffset += DISPLAY_CHAR_SIZE_X;
+                    renderLoresBlock(displayOffset,
+                        displayPalette[apple.mem[address] & 0xf],
+                        displayPalette[(apple.mem[address] & 0xf0) >> 4]);
+                    displayOffset += DISPLAY_CHAR_SIZE_X;
+                }
+                displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
+            } else {
+                displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
+            }
+        }
+    }
 
-	private final void renderDoubleHiresBlock(int destOffset) {
-		renderDoubleHiresScanLine(destOffset, hiresWord[0]); destOffset += DISPLAY_SIZE_X;
-		renderDoubleHiresScanLine(destOffset, hiresWord[1]); destOffset += DISPLAY_SIZE_X;
-		renderDoubleHiresScanLine(destOffset, hiresWord[2]); destOffset += DISPLAY_SIZE_X;
-		renderDoubleHiresScanLine(destOffset, hiresWord[3]); destOffset += DISPLAY_SIZE_X;
-		renderDoubleHiresScanLine(destOffset, hiresWord[4]); destOffset += DISPLAY_SIZE_X;
-		renderDoubleHiresScanLine(destOffset, hiresWord[5]); destOffset += DISPLAY_SIZE_X;
-		renderDoubleHiresScanLine(destOffset, hiresWord[6]); destOffset += DISPLAY_SIZE_X;
-		renderDoubleHiresScanLine(destOffset, hiresWord[7]);
-	}
+    /**
+     * Render double lores canvas
+     */
+    private void renderDoubleLores(int baseAddress, boolean isMixedMode) {
+        int screenCharY, screenCharYEnd = isMixedMode ? 20 : 24;
+        int displayOffset;
+        int address, addressEnd, addressStart;
 
-	private final void calcNextDoubleHiresWord(int hiresWordIndex, int byte1, int byte2, int byte3, int byte4) {
-		hiresWordNext[hiresWordIndex] = (
-			((byte1 & 0x7f) << 2) | ((byte2 & 0x7f) << 9) | 
-			((byte3 & 0x7f) << 16) | ((byte4 & 0x7f) << 23) |
-			(hiresWord[hiresWordIndex] >> 28));
-		hiresWord[hiresWordIndex] |= (hiresWordNext[hiresWordIndex] << 28);
-	}
+        displayOffset = 0;
+        for (screenCharY = 0; screenCharY < screenCharYEnd; screenCharY++) {
+            addressStart = baseAddress + textLineAddress[screenCharY];
 
-	private final void calcNextDoubleHiresWords(int address) {
-		calcNextDoubleHiresWord(0, 
-			apple.mem[address + 0x10000], apple.mem[address + 0x00000], 
-			apple.mem[address + 0x10001], apple.mem[address + 0x00001]);
-		calcNextDoubleHiresWord(1,
-			apple.mem[address + 0x10400], apple.mem[address + 0x00400],
-			apple.mem[address + 0x10401], apple.mem[address + 0x00401]);
-		calcNextDoubleHiresWord(2,
-			apple.mem[address + 0x10800], apple.mem[address + 0x00800],
-			apple.mem[address + 0x10801], apple.mem[address + 0x00801]);
-		calcNextDoubleHiresWord(3,
-			apple.mem[address + 0x10c00], apple.mem[address + 0x00c00],
-			apple.mem[address + 0x10c01], apple.mem[address + 0x00c01]);
-		calcNextDoubleHiresWord(4,
-			apple.mem[address + 0x11000], apple.mem[address + 0x01000],
-			apple.mem[address + 0x11001], apple.mem[address + 0x01001]);
-		calcNextDoubleHiresWord(5,
-			apple.mem[address + 0x11400], apple.mem[address + 0x01400],
-			apple.mem[address + 0x11401], apple.mem[address + 0x01401]);
-		calcNextDoubleHiresWord(6,
-			apple.mem[address + 0x11800], apple.mem[address + 0x01800],
-			apple.mem[address + 0x11801], apple.mem[address + 0x01801]);
-		calcNextDoubleHiresWord(7,
-			apple.mem[address + 0x11c00], apple.mem[address + 0x01c00],
-			apple.mem[address + 0x11c01], apple.mem[address + 0x01c01]);
-	}	
+            if (graphicsDirty[addressStart >> 7]) {
+                addressEnd = addressStart + 40;
 
-	private void renderDoubleHires(int baseAddress, boolean isMixedMode) {
-		int screenCharY, screenCharYEnd = isMixedMode ? 20 : 24;
-		int displayOffset;
-		int address, addressEnd, addressStart;
-		
-		displayOffset = 0;
-		for (screenCharY = 0; screenCharY < screenCharYEnd; screenCharY++) {
-			addressStart = baseAddress + textLineAddress[screenCharY];
-			
-			if (graphicsDirty[addressStart >> 7]) {
-				addressEnd = addressStart + 40;
+                for (address = addressStart; address < addressEnd; address++) {
+                    renderLoresBlock(displayOffset,
+                        displayPalette[apple.mem[address + 0x10000] & 0xf],
+                        displayPalette[(apple.mem[address + 0x10000] & 0xf0) >> 4]);
+                    displayOffset += DISPLAY_CHAR_SIZE_X;
+                    renderLoresBlock(displayOffset,
+                        displayPalette[apple.mem[address] & 0xf],
+                        displayPalette[(apple.mem[address] & 0xf0) >> 4]);
+                    displayOffset += DISPLAY_CHAR_SIZE_X;
+                }
+                displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
+            } else {
+                displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
+            }
+        }
+    }
 
-				resetHiresWords();
-				calcNextDoubleHiresWords(addressStart);
-				for (address = (addressStart + 2); address < addressEnd; address += 2) {
-					bufferHiresWords();
-					calcNextDoubleHiresWords(address);
-					renderDoubleHiresBlock(displayOffset);
-					displayOffset += DISPLAY_CHAR_SIZE_X * 4;
-				}
-				bufferHiresWords();
-				renderDoubleHiresBlock(displayOffset);
-				displayOffset += DISPLAY_CHAR_SIZE_X * 4;
-				
-				displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
-			} else {
-				displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
-			}
-		}
-	}
+    /**
+     * Render hires canvas
+     */
+    private final void renderHiresWord(int destOffset, int hiresNibble) {
+        displayImageBuffer[destOffset + 0] = displayPalette[(hiresNibble >> 0) & 0xf];
+        displayImageBuffer[destOffset + 1] = displayPalette[(hiresNibble >> 4) & 0xf];
+        displayImageBuffer[destOffset + 2] = displayPalette[(hiresNibble >> 8) & 0xf];
+        displayImageBuffer[destOffset + 3] = displayPalette[(hiresNibble >> 12) & 0xf];
+    }
+
+    private final void renderHiresScanLine(int destOffset, int hiresWord) {
+        renderHiresWord(destOffset + 0, hiresLookup[(hiresWord >> 0) & 0xff]);
+        renderHiresWord(destOffset + 4, hiresLookup[(hiresWord >> 4) & 0xff]);
+        renderHiresWord(destOffset + 8, hiresLookup[(hiresWord >> 8) & 0xff]);
+        renderHiresWord(destOffset + 12, hiresLookup[(hiresWord >> 12) & 0xff]);
+        renderHiresWord(destOffset + 16, hiresLookup[(hiresWord >> 16) & 0xff]);
+        renderHiresWord(destOffset + 20, hiresLookup[(hiresWord >> 20) & 0xff]);
+        renderHiresWord(destOffset + 24, hiresLookup[(hiresWord >> 24) & 0xff]);
+    }
+
+    private final void renderHiresBlock(int destOffset) {
+        renderHiresScanLine(destOffset, hiresWord[0]); destOffset += DISPLAY_SIZE_X;
+        renderHiresScanLine(destOffset, hiresWord[1]); destOffset += DISPLAY_SIZE_X;
+        renderHiresScanLine(destOffset, hiresWord[2]); destOffset += DISPLAY_SIZE_X;
+        renderHiresScanLine(destOffset, hiresWord[3]); destOffset += DISPLAY_SIZE_X;
+        renderHiresScanLine(destOffset, hiresWord[4]); destOffset += DISPLAY_SIZE_X;
+        renderHiresScanLine(destOffset, hiresWord[5]); destOffset += DISPLAY_SIZE_X;
+        renderHiresScanLine(destOffset, hiresWord[6]); destOffset += DISPLAY_SIZE_X;
+        renderHiresScanLine(destOffset, hiresWord[7]);
+    }
+
+    private final void resetHiresWords() {
+        hiresWord[0] = 0;
+        hiresWord[1] = 0;
+        hiresWord[2] = 0;
+        hiresWord[3] = 0;
+        hiresWord[4] = 0;
+        hiresWord[5] = 0;
+        hiresWord[6] = 0;
+        hiresWord[7] = 0;
+    }
+
+    private final void bufferHiresWords() {
+        hiresWord[0] = hiresWordNext[0];
+        hiresWord[1] = hiresWordNext[1];
+        hiresWord[2] = hiresWordNext[2];
+        hiresWord[3] = hiresWordNext[3];
+        hiresWord[4] = hiresWordNext[4];
+        hiresWord[5] = hiresWordNext[5];
+        hiresWord[6] = hiresWordNext[6];
+        hiresWord[7] = hiresWordNext[7];
+    }
+
+    private final void calcNextHiresWord(int hiresWordIndex, int byteEven, int byteOdd) {
+        hiresWordNext[hiresWordIndex] = hiresWord[hiresWordIndex] >> 28;
+        hiresWordNext[hiresWordIndex] |=
+            hiresEvenOddToWord[(byteEven & 0xff) | ((hiresWordNext[hiresWordIndex] & 0x2) << 7)] << 2;
+        hiresWordNext[hiresWordIndex] |=
+            hiresEvenOddToWord[(byteOdd & 0xff) | ((hiresWordNext[hiresWordIndex] & 0x8000) >> 7)] << 16;
+        hiresWord[hiresWordIndex] |= (hiresWordNext[hiresWordIndex] << 28);
+    }
+
+    private final void calcNextHiresWords(int address) {
+        calcNextHiresWord(0, apple.mem[address + 0x00000], apple.mem[address + 0x00001]);
+        calcNextHiresWord(1, apple.mem[address + 0x00400], apple.mem[address + 0x00401]);
+        calcNextHiresWord(2, apple.mem[address + 0x00800], apple.mem[address + 0x00801]);
+        calcNextHiresWord(3, apple.mem[address + 0x00c00], apple.mem[address + 0x00c01]);
+        calcNextHiresWord(4, apple.mem[address + 0x01000], apple.mem[address + 0x01001]);
+        calcNextHiresWord(5, apple.mem[address + 0x01400], apple.mem[address + 0x01401]);
+        calcNextHiresWord(6, apple.mem[address + 0x01800], apple.mem[address + 0x01801]);
+        calcNextHiresWord(7, apple.mem[address + 0x01c00], apple.mem[address + 0x01c01]);
+    }
+
+    private void renderHires(int baseAddress, boolean isMixedMode) {
+        int screenCharY, screenCharYEnd = isMixedMode ? 20 : 24;
+        int displayOffset;
+        int address, addressEnd, addressStart;
+
+        displayOffset = 0;
+        for (screenCharY = 0; screenCharY < screenCharYEnd; screenCharY++) {
+            addressStart = baseAddress + textLineAddress[screenCharY];
+
+            if (graphicsDirty[addressStart >> 7]) {
+                addressEnd = addressStart + 40;
+
+                resetHiresWords();
+                calcNextHiresWords(addressStart);
+                for (address = (addressStart + 2); address < addressEnd; address += 2) {
+                    bufferHiresWords();
+                    calcNextHiresWords(address);
+                    renderHiresBlock(displayOffset);
+                    displayOffset += DISPLAY_CHAR_SIZE_X * 4;
+                }
+                bufferHiresWords();
+                renderHiresBlock(displayOffset);
+                displayOffset += DISPLAY_CHAR_SIZE_X * 4;
+
+                displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
+            } else {
+                displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
+            }
+        }
+    }
+
+    /**
+     * Render double hires canvas
+     */
+    private final void renderDoubleHiresWord(int destOffset, int hiresNibble) {
+        displayImageBuffer[destOffset + 0] = doubleHiresPalette[(hiresNibble >> 0) & 0xf];
+        displayImageBuffer[destOffset + 1] = doubleHiresPalette[(hiresNibble >> 4) & 0xf];
+        displayImageBuffer[destOffset + 2] = doubleHiresPalette[(hiresNibble >> 8) & 0xf];
+        displayImageBuffer[destOffset + 3] = doubleHiresPalette[(hiresNibble >> 12) & 0xf];
+    }
+
+    private final void renderDoubleHiresScanLine(int destOffset, int hiresWord) {
+        renderDoubleHiresWord(destOffset + 0, hiresLookup[(hiresWord >> 0) & 0xff]);
+        renderDoubleHiresWord(destOffset + 4, hiresLookup[(hiresWord >> 4) & 0xff]);
+        renderDoubleHiresWord(destOffset + 8, hiresLookup[(hiresWord >> 8) & 0xff]);
+        renderDoubleHiresWord(destOffset + 12, hiresLookup[(hiresWord >> 12) & 0xff]);
+        renderDoubleHiresWord(destOffset + 16, hiresLookup[(hiresWord >> 16) & 0xff]);
+        renderDoubleHiresWord(destOffset + 20, hiresLookup[(hiresWord >> 20) & 0xff]);
+        renderDoubleHiresWord(destOffset + 24, hiresLookup[(hiresWord >> 24) & 0xff]);
+    }
+
+    private final void renderDoubleHiresBlock(int destOffset) {
+        renderDoubleHiresScanLine(destOffset, hiresWord[0]); destOffset += DISPLAY_SIZE_X;
+        renderDoubleHiresScanLine(destOffset, hiresWord[1]); destOffset += DISPLAY_SIZE_X;
+        renderDoubleHiresScanLine(destOffset, hiresWord[2]); destOffset += DISPLAY_SIZE_X;
+        renderDoubleHiresScanLine(destOffset, hiresWord[3]); destOffset += DISPLAY_SIZE_X;
+        renderDoubleHiresScanLine(destOffset, hiresWord[4]); destOffset += DISPLAY_SIZE_X;
+        renderDoubleHiresScanLine(destOffset, hiresWord[5]); destOffset += DISPLAY_SIZE_X;
+        renderDoubleHiresScanLine(destOffset, hiresWord[6]); destOffset += DISPLAY_SIZE_X;
+        renderDoubleHiresScanLine(destOffset, hiresWord[7]);
+    }
+
+    private final void calcNextDoubleHiresWord(int hiresWordIndex, int byte1, int byte2, int byte3, int byte4) {
+        hiresWordNext[hiresWordIndex] = (
+            ((byte1 & 0x7f) << 2) | ((byte2 & 0x7f) << 9) |
+            ((byte3 & 0x7f) << 16) | ((byte4 & 0x7f) << 23) |
+            (hiresWord[hiresWordIndex] >> 28));
+        hiresWord[hiresWordIndex] |= (hiresWordNext[hiresWordIndex] << 28);
+    }
+
+    private final void calcNextDoubleHiresWords(int address) {
+        calcNextDoubleHiresWord(0,
+            apple.mem[address + 0x10000], apple.mem[address + 0x00000],
+            apple.mem[address + 0x10001], apple.mem[address + 0x00001]);
+        calcNextDoubleHiresWord(1,
+            apple.mem[address + 0x10400], apple.mem[address + 0x00400],
+            apple.mem[address + 0x10401], apple.mem[address + 0x00401]);
+        calcNextDoubleHiresWord(2,
+            apple.mem[address + 0x10800], apple.mem[address + 0x00800],
+            apple.mem[address + 0x10801], apple.mem[address + 0x00801]);
+        calcNextDoubleHiresWord(3,
+            apple.mem[address + 0x10c00], apple.mem[address + 0x00c00],
+            apple.mem[address + 0x10c01], apple.mem[address + 0x00c01]);
+        calcNextDoubleHiresWord(4,
+            apple.mem[address + 0x11000], apple.mem[address + 0x01000],
+            apple.mem[address + 0x11001], apple.mem[address + 0x01001]);
+        calcNextDoubleHiresWord(5,
+            apple.mem[address + 0x11400], apple.mem[address + 0x01400],
+            apple.mem[address + 0x11401], apple.mem[address + 0x01401]);
+        calcNextDoubleHiresWord(6,
+            apple.mem[address + 0x11800], apple.mem[address + 0x01800],
+            apple.mem[address + 0x11801], apple.mem[address + 0x01801]);
+        calcNextDoubleHiresWord(7,
+            apple.mem[address + 0x11c00], apple.mem[address + 0x01c00],
+            apple.mem[address + 0x11c01], apple.mem[address + 0x01c01]);
+    }
+
+    private void renderDoubleHires(int baseAddress, boolean isMixedMode) {
+        int screenCharY, screenCharYEnd = isMixedMode ? 20 : 24;
+        int displayOffset;
+        int address, addressEnd, addressStart;
+
+        displayOffset = 0;
+        for (screenCharY = 0; screenCharY < screenCharYEnd; screenCharY++) {
+            addressStart = baseAddress + textLineAddress[screenCharY];
+
+            if (graphicsDirty[addressStart >> 7]) {
+                addressEnd = addressStart + 40;
+
+                resetHiresWords();
+                calcNextDoubleHiresWords(addressStart);
+                for (address = (addressStart + 2); address < addressEnd; address += 2) {
+                    bufferHiresWords();
+                    calcNextDoubleHiresWords(address);
+                    renderDoubleHiresBlock(displayOffset);
+                    displayOffset += DISPLAY_CHAR_SIZE_X * 4;
+                }
+                bufferHiresWords();
+                renderDoubleHiresBlock(displayOffset);
+                displayOffset += DISPLAY_CHAR_SIZE_X * 4;
+
+                displayOffset += (DISPLAY_CHAR_SIZE_Y - 1) * DISPLAY_SIZE_X;
+            } else {
+                displayOffset += DISPLAY_CHAR_SIZE_Y * DISPLAY_SIZE_X;
+            }
+        }
+    }
 }
diff --git a/src/main/java/vavi/apps/appleii/AppleIIApp.java b/src/main/java/vavi/apps/appleii/AppleIIApp.java
index 13d3d20..1945e10 100644
--- a/src/main/java/vavi/apps/appleii/AppleIIApp.java
+++ b/src/main/java/vavi/apps/appleii/AppleIIApp.java
@@ -2,7 +2,7 @@
  * Copyright (c) 2008 by umjammer, All rights reserved.
  *
  * Programmed by umjammer
- * 
+ *
  * Released under the GPL
  */
 
@@ -48,7 +48,7 @@ import org.havi.ui.HSceneFactory;
 
 /**
  * AppleIIApp.
- * 
+ *
  * @author umjammer
  * @version 0.00 080912 umjammer initial version <br>
  */
@@ -120,7 +120,7 @@ e.printStackTrace(System.err);
         private GameVC gameVC;
 
         /**
-         * <pre> 
+         * <pre>
          *  1
          *  2
          *  3
@@ -136,12 +136,12 @@ e.printStackTrace(System.err);
          *  G   restart
          *  Y   reset
          *  O   pad button right
-         *  #   pad button left   
+         *  #   pad button left
          *  U   pad up
          *  L   pad left
          *  R   pad right
          *  D   pad down
-         * </pre> 
+         * </pre>
          */
         class NormalVC {
 
@@ -336,20 +336,20 @@ try {
 } catch (Throwable t) { // for xletview bug
  t.printStackTrace(System.err);
                 files = new File[] {
-                    new File(file, "Lode Runner.dsk"), 
-                    new File(file, "Mystery House.dsk"), 
-                    new File(file, "Tetris II.dsk"), 
-                    new File(file, "tzone1a.nib"), 
-                    new File(file, "tzone1b.nib"), 
-                    new File(file, "tzone2c.nib"), 
-                    new File(file, "tzone2d.nib"), 
-                    new File(file, "tzone3e.nib"), 
-                    new File(file, "tzone3f.nib"), 
-                    new File(file, "tzone4g.nib"), 
-                    new File(file, "tzone4h.nib"), 
-                    new File(file, "tzone5i.nib"), 
-                    new File(file, "tzone5j.nib"), 
-                    new File(file, "tzone6k.nib"), 
+                    new File(file, "Lode Runner.dsk"),
+                    new File(file, "Mystery House.dsk"),
+                    new File(file, "Tetris II.dsk"),
+                    new File(file, "tzone1a.nib"),
+                    new File(file, "tzone1b.nib"),
+                    new File(file, "tzone2c.nib"),
+                    new File(file, "tzone2d.nib"),
+                    new File(file, "tzone3e.nib"),
+                    new File(file, "tzone3f.nib"),
+                    new File(file, "tzone4g.nib"),
+                    new File(file, "tzone4h.nib"),
+                    new File(file, "tzone5i.nib"),
+                    new File(file, "tzone5j.nib"),
+                    new File(file, "tzone6k.nib"),
                     new File(file, "tzone6l.nib"),
                 };
 }
@@ -485,10 +485,10 @@ stat.clear();
                     break;
                 }
             }
-            
+
             void mousePressed(MouseEvent e) {
                 int modifiers = e.getModifiers();
-                
+
                 if ((modifiers & InputEvent.BUTTON3_MASK) != 0) {
                     game.setButton(0, true);
                 }
@@ -499,7 +499,7 @@ stat.clear();
 
             void mouseReleased(MouseEvent e) {
                 int modifiers = e.getModifiers();
-                
+
                 if ((modifiers & InputEvent.BUTTON3_MASK) != 0) {
                     game.setButton(0, false);
                 }
@@ -668,7 +668,7 @@ try {
             this.diskVCs[0] = new DiskVC(0);
             this.diskVCs[1] = new DiskVC(1);
             this.gameVC = new GameVC();
-    
+
             mode = MODE_NORMAL;
 System.err.println("mode: -> MODE_NORMAL");
 
@@ -680,7 +680,7 @@ System.err.println("mode: -> MODE_NORMAL");
         }
 
         /**
-         * <pre> 
+         * <pre>
          *  B   mode change
          *  G   restart
          *  O   key select
@@ -688,12 +688,12 @@ System.err.println("mode: -> MODE_NORMAL");
          *  L   key left
          *  R   key right
          *  D   key down
-         * </pre> 
+         * </pre>
          */
         class KeyBoard {
             Image image;
             int[][] bounds = {
-                { 6, 14, 22, 14 }, 
+                { 6, 14, 22, 14 },
                 { 31, 14, 22, 14 },
                 { 56, 14, 22, 14 },
                 { 82, 14, 22, 14 },
@@ -780,7 +780,7 @@ System.err.println("mode: -> MODE_NORMAL");
             };
             /** l, r, u, d */
             int[][] navigation = {
-                { 13, 1, 67, 14 }, 
+                { 13, 1, 67, 14 },
                 { 0, 2, 68, 15 },
                 { 1, 3, 69, 16 },
                 { 2, 4, 70, 17 },
@@ -886,7 +886,7 @@ System.err.println("mode: -> MODE_NORMAL");
             final int KEY_SHIFT = -2;
             int keyIndex;
             /** normal, shift */
-            int[][] keyDatum = {
+            int[][] keyData = {
                 { 0x1b, 0x1b }, // esc
                 { -1, -1 }, // f1
                 { -1, -1 },
@@ -1007,10 +1007,10 @@ stat.clear();
                 }
             }
             private void keyPressed() {
-                int keyCode = keyDatum[keyIndex][shiftIndex];
+                int keyCode = keyData[keyIndex][shiftIndex];
                 switch (keyCode) {
                 case KEY_SHIFT:
-                    shiftIndex = 1 - shiftIndex; 
+                    shiftIndex = 1 - shiftIndex;
 System.err.println("VK: SHIFT: " + (shiftIndex == 1 ? "ON" : "OFF"));
                     break;
                 default:
@@ -1071,7 +1071,7 @@ if (stat.size() > 0) {
         /** */
         class GameVC {
             int displayScaledSizeX;
-            int displayScaledSizeY; 
+            int displayScaledSizeY;
             MemoryImageSource mis;
             Image displayImage;
             Image displayImagePaused;
@@ -1089,7 +1089,7 @@ if (stat.size() > 0) {
             }
             /** */
             void paint(Graphics g) {
-    
+
                 mis.newPixels();
 
                 g.drawImage(displayImage,
@@ -1099,17 +1099,17 @@ if (stat.size() > 0) {
 
                 if (game.isStatMode()) {
                     g.setColor(Color.black);
-                    g.fillRect(displayScaledSizeX, 0, 512, 600); 
+                    g.fillRect(displayScaledSizeX, 0, 512, 600);
                     drawStatInfo(g);
                 }
-    
+
                 if (game.isPaused()) {
                     g.drawImage(displayImagePaused,
                         0, 0, displayScaledSizeX, displayScaledSizeY,
                         0, 0, AppleDisplay.DISPLAY_SIZE_X, AppleDisplay.DISPLAY_SIZE_Y,
                         MyView.this);
                 }
-    
+
                 if (game.isGlare()) {
                     g.drawImage(displayImageGlare,
                         0, 0, displayScaledSizeX, displayScaledSizeY,
diff --git a/src/main/java/vavi/apps/appleii/AppleIIGo.java b/src/main/java/vavi/apps/appleii/AppleIIGo.java
index aed78a3..5eb01d1 100644
--- a/src/main/java/vavi/apps/appleii/AppleIIGo.java
+++ b/src/main/java/vavi/apps/appleii/AppleIIGo.java
@@ -1,6 +1,6 @@
 /*
  * AppleIIGo
- * The Java Apple II Emulator 
+ * The Java Apple II Emulator
  * (C) 2006 by Marc S. Ressl(ressl@lonetree.com)
  * Released under the GPL
  */
@@ -13,35 +13,35 @@ package vavi.apps.appleii;
  * Connects EmAppleII, AppleCanvas
  */
 public class AppleIIGo {
-	// Class instances
-	private EmAppleII apple;
-	private AppleDisplay display;
-//	private AppleSpeaker speaker;
-	private DiskII disk;
+    // Class instances
+    private EmAppleII apple;
+    private AppleDisplay display;
+//    private AppleSpeaker speaker;
+    private DiskII disk;
 
-	// Machine variables
-	private boolean isCpuPaused;
-	private boolean isCpuDebugEnabled;
+    // Machine variables
+    private boolean isCpuPaused;
+    private boolean isCpuDebugEnabled;
 
     /** */
     public boolean isCpuDebugEnabled() {
         return isCpuDebugEnabled;
-    }   
+    }
 
     // Keyboard variables
-	private boolean keyboardUppercaseOnly;
+    private boolean keyboardUppercaseOnly;
 
     // Paddle variables
-	private boolean isPaddleInverted;
+    private boolean isPaddleInverted;
 
-	// Disk variables
-	private String diskDriveResource[] = new String[2];
+    // Disk variables
+    private String diskDriveResource[] = new String[2];
 
-	public String getDiskDriveResource(int drive) {
-	    return diskDriveResource[drive];
-	}
+    public String getDiskDriveResource(int drive) {
+        return diskDriveResource[drive];
+    }
 
-	private boolean diskWritable;
+    private boolean diskWritable;
 
     /** */
     public interface View {
@@ -153,7 +153,7 @@ public class AppleIIGo {
         isGlare = value;
         display.requestRefresh();
     }
-    
+
     /**
      * Get glare
      */
@@ -194,92 +194,92 @@ public class AppleIIGo {
     }
 
     /**
- 	 * On applet initialization
-	 */
-	public void init() {
+      * On applet initialization
+     */
+    public void init() {
 System.err.println("init()");
 
-		// Activate listeners
+        // Activate listeners
 
-		// Initialize Apple II emulator
-		apple = new EmAppleII(view);
-		loadRom(getParameter("cpuRom", ""));
-		apple.setCpuSpeed(new Integer(getParameter("cpuSpeed", "1000")).intValue());
-		isCpuPaused = getParameter("cpuPaused", "false").equals("true");
-		isCpuDebugEnabled = getParameter("cpuDebugEnabled", "false").equals("true");
-		apple.setStepMode(getParameter("cpuStepMode", "false").equals("true"));
-	
-		// Keyboard
-		keyboardUppercaseOnly = getParameter("keyboardUppercaseOnly", "true").equals("true");
+        // Initialize Apple II emulator
+        apple = new EmAppleII(view);
+        loadRom(getParameter("cpuRom", ""));
+        apple.setCpuSpeed(new Integer(getParameter("cpuSpeed", "1000")).intValue());
+        isCpuPaused = getParameter("cpuPaused", "false").equals("true");
+        isCpuDebugEnabled = getParameter("cpuDebugEnabled", "false").equals("true");
+        apple.setStepMode(getParameter("cpuStepMode", "false").equals("true"));
 
-		// Display
-		display = new AppleDisplay(apple);
-		display.setScale(new Float(getParameter("displayScale", "1")).floatValue());
-		display.setRefreshRate(new Integer(getParameter("displayRefreshRate", "10")).intValue());
-		display.setColorMode(new Integer(getParameter("displayColorMode", "0")).intValue());
-		setStatMode(getParameter("displayStatMode", "false").equals("true"));
-		setGlare(getParameter("displayGlare", "false").equals("true"));
+        // Keyboard
+        keyboardUppercaseOnly = getParameter("keyboardUppercaseOnly", "true").equals("true");
 
-		// Speaker
-//		speaker = new AppleSpeaker(apple);
-//		speaker.setVolume(new Integer(getAppletParameter("speakerVolume", "3")).intValue());
-		
-		// Peripherals
-		disk = new DiskII();
-		apple.setPeripheral(disk, 6);
+        // Display
+        display = new AppleDisplay(apple);
+        display.setScale(new Float(getParameter("displayScale", "1")).floatValue());
+        display.setRefreshRate(new Integer(getParameter("displayRefreshRate", "10")).intValue());
+        display.setColorMode(new Integer(getParameter("displayColorMode", "0")).intValue());
+        setStatMode(getParameter("displayStatMode", "false").equals("true"));
+        setGlare(getParameter("displayGlare", "false").equals("true"));
 
-		// Initialize disk drives
-		diskWritable = getParameter("diskWritable", "false").equals("true");
-		mountDisk(0, getParameter("diskDrive1", ""));
-		mountDisk(1, getParameter("diskDrive2", ""));
-	}
+        // Speaker
+//        speaker = new AppleSpeaker(apple);
+//        speaker.setVolume(new Integer(getAppletParameter("speakerVolume", "3")).intValue());
 
-	public void start() {
-		// Start CPU
-		if (!isCpuPaused) {
-			resume();
-		}
-	}
+        // Peripherals
+        disk = new DiskII();
+        apple.setPeripheral(disk, 6);
+
+        // Initialize disk drives
+        diskWritable = getParameter("diskWritable", "false").equals("true");
+        mountDisk(0, getParameter("diskDrive1", ""));
+        mountDisk(1, getParameter("diskDrive2", ""));
+    }
+
+    public void start() {
+        // Start CPU
+        if (!isCpuPaused) {
+            resume();
+        }
+    }
 
     /**
- 	 * On applet destruction
-	 */
-	public void destroy() {
+      * On applet destruction
+     */
+    public void destroy() {
 System.err.println("destroy()");
-		unmountDisk(0);
-		unmountDisk(1);
-	}
-	
-	/**
- 	 * Pause emulator
-	 */
-	public void pause() {
+        unmountDisk(0);
+        unmountDisk(1);
+    }
+
+    /**
+      * Pause emulator
+     */
+    public void pause() {
 System.err.println("pause()");
-		isCpuPaused = true;
-		apple.setPaused(isCpuPaused);
-		display.setPaused(isCpuPaused);
-//		speaker.setPaused(isCpuPaused);
-	}
+        isCpuPaused = true;
+        apple.setPaused(isCpuPaused);
+        display.setPaused(isCpuPaused);
+//        speaker.setPaused(isCpuPaused);
+    }
 
-	/**
- 	 * Resume emulator
-	 */
-	public void resume() {
+    /**
+      * Resume emulator
+     */
+    public void resume() {
 System.err.println("resume()");
-		isCpuPaused = false;
-//		speaker.setPaused(isCpuPaused);
-		display.setPaused(isCpuPaused);
-		apple.setPaused(isCpuPaused);
-	}
+        isCpuPaused = false;
+//        speaker.setPaused(isCpuPaused);
+        display.setPaused(isCpuPaused);
+        apple.setPaused(isCpuPaused);
+    }
 
-	/**
- 	 * Restarts emulator
-	 */
-	public void restart() {
+    /**
+      * Restarts emulator
+     */
+    public void restart() {
 System.err.println("restart()");
-		apple.restart();
-	}
-	
+        apple.restart();
+    }
+
     /**
      * Resets emulator
      */
@@ -288,82 +288,82 @@ System.err.println("reset()");
         apple.reset();
     }
 
-	/**
-	 * Load ROM
-	 */
-	public void loadRom(String resource) {
+    /**
+     * Load ROM
+     */
+    public void loadRom(String resource) {
 System.err.println("loadRom(resource: " + resource + ")");
         apple.loadRom(dao, resource);
-	}
-	
-	/**
- 	 * Mount a disk
-	 */
-	public boolean mountDisk(int drive, String resource) {
+    }
+
+    /**
+      * Mount a disk
+     */
+    public boolean mountDisk(int drive, String resource) {
 System.err.println("mountDisk(drive: " + drive + ", resource: " + resource + ")");
 
-		if ((drive < 0) || (drive > 2)) {
-			return false;
-		}
-			
-		try {
-			unmountDisk(drive);
+        if ((drive < 0) || (drive > 2)) {
+            return false;
+        }
 
-			diskDriveResource[drive] = resource;
+        try {
+            unmountDisk(drive);
+
+            diskDriveResource[drive] = resource;
 
 System.err.println("mount: dirve: " + drive  + ", " + resource);
-			disk.readDisk(dao, drive, resource, 254, false);
+            disk.readDisk(dao, drive, resource, 254, false);
 
-			return true;
-		} catch (Throwable e) {
+            return true;
+        } catch (Throwable e) {
 if (e instanceof IllegalStateException) {
  System.err.println("mount: drive: " + drive + ": no disk");
 } else {
  e.printStackTrace(System.err);
 }
             return false;
-		}
-	}
+        }
+    }
 
-	/**
- 	 * Unmount a disk
-	 */
-	public void unmountDisk(int drive) {
+    /**
+      * Unmount a disk
+     */
+    public void unmountDisk(int drive) {
 System.err.println("unmount: drive: " + drive);
-		if ((drive < 0) || (drive > 2)) {
-			return;
-		}
+        if ((drive < 0) || (drive > 2)) {
+            return;
+        }
 
-		if (!diskWritable) {
+        if (!diskWritable) {
 System.err.println("unmount: drive: " + drive + ", not writable");
-			return;
-		}
-			
-		try {
-			disk.writeDisk(drive, diskDriveResource[drive]);
-		} catch (Throwable e) {
+            return;
+        }
+
+        try {
+            disk.writeDisk(drive, diskDriveResource[drive]);
+        } catch (Throwable e) {
 if (e instanceof NullPointerException) {
  System.err.println("unmount: drive: " + drive + ": no disk");
 } else {
  e.printStackTrace(System.err);
 }
-		}
-	}
+        }
+    }
 
-	/**
- 	 * Set color mode
-	 */
-	public void setColorMode(int value) {
+    /**
+      * Set color mode
+     */
+    public void setColorMode(int value) {
 System.err.println("setColorMode(value: " + value + ")");
-		display.setColorMode(value);
-	}
+        display.setColorMode(value);
+    }
 
-	/**
- 	 * Get disk activity
-	 */
-	public boolean getDiskActivity() {
-		return (!isCpuPaused && disk.isMotorOn());
-	}
+    /**
+      * Get disk activity
+     */
+    public boolean getDiskActivity() {
+        return (!isCpuPaused && disk.isMotorOn());
+    }
 }
 
 /* */
diff --git a/src/main/java/vavi/apps/appleii/DiskII.java b/src/main/java/vavi/apps/appleii/DiskII.java
index bf8c3f6..1e3b1d8 100644
--- a/src/main/java/vavi/apps/appleii/DiskII.java
+++ b/src/main/java/vavi/apps/appleii/DiskII.java
@@ -5,276 +5,276 @@
  * Released under the GPL
  * Based on work by Doug Kwan
  */
- 
+
 package vavi.apps.appleii;
 
 
 public class DiskII extends Peripheral {
-	// ROM (with boot wait cycle optimization)
-	private static final int[] rom = {
+    // ROM (with boot wait cycle optimization)
+    private static final int[] rom = {
         0xa2, 0x20, 0xa0, 0x00, 0xa2, 0x03, 0x86, 0x3c, 0x8a, 0x0a, 0x24, 0x3c, 0xf0, 0x10, 0x05, 0x3c,
         0x49, 0xff, 0x29, 0x7e, 0xb0, 0x08, 0x4a, 0xd0, 0xfb, 0x98, 0x9d, 0x56, 0x03, 0xc8, 0xe8, 0x10,
-		0xe5, 0x20, 0x58, 0xff, 0xba, 0xbd, 0x00, 0x01, 0x0a, 0x0a, 0x0a, 0x0a, 0x85, 0x2b, 0xaa, 0xbd,
-		0x8e, 0xc0, 0xbd, 0x8c, 0xc0, 0xbd, 0x8a, 0xc0, 0xbd, 0x89, 0xc0, 0xa0, 0x50, 0xbd, 0x80, 0xc0,
-		0x98, 0x29, 0x03, 0x0a, 0x05, 0x2b, 0xaa, 0xbd, 0x81, 0xc0, 0xa9, 0x56, 0xa9, 0x00, 0xea, 0x88,
-		0x10, 0xeb, 0x85, 0x26, 0x85, 0x3d, 0x85, 0x41, 0xa9, 0x08, 0x85, 0x27, 0x18, 0x08, 0xbd, 0x8c,
-		0xc0, 0x10, 0xfb, 0x49, 0xd5, 0xd0, 0xf7, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0xc9, 0xaa, 0xd0, 0xf3,
-		0xea, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0xc9, 0x96, 0xf0, 0x09, 0x28, 0x90, 0xdf, 0x49, 0xad, 0xf0,
-		0x25, 0xd0, 0xd9, 0xa0, 0x03, 0x85, 0x40, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0x2a, 0x85, 0x3c, 0xbd,
-		0x8c, 0xc0, 0x10, 0xfb, 0x25, 0x3c, 0x88, 0xd0, 0xec, 0x28, 0xc5, 0x3d, 0xd0, 0xbe, 0xa5, 0x40,
-		0xc5, 0x41, 0xd0, 0xb8, 0xb0, 0xb7, 0xa0, 0x56, 0x84, 0x3c, 0xbc, 0x8c, 0xc0, 0x10, 0xfb, 0x59,
-		0xd6, 0x02, 0xa4, 0x3c, 0x88, 0x99, 0x00, 0x03, 0xd0, 0xee, 0x84, 0x3c, 0xbc, 0x8c, 0xc0, 0x10,
-		0xfb, 0x59, 0xd6, 0x02, 0xa4, 0x3c, 0x91, 0x26, 0xc8, 0xd0, 0xef, 0xbc, 0x8c, 0xc0, 0x10, 0xfb,
-		0x59, 0xd6, 0x02, 0xd0, 0x87, 0xa0, 0x00, 0xa2, 0x56, 0xca, 0x30, 0xfb, 0xb1, 0x26, 0x5e, 0x00,
-		0x03, 0x2a, 0x5e, 0x00, 0x03, 0x2a, 0x91, 0x26, 0xc8, 0xd0, 0xee, 0xe6, 0x27, 0xe6, 0x3d, 0xa5,
-		0x3d, 0xcd, 0x00, 0x08, 0xa6, 0x2b, 0x90, 0xdb, 0x4c, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
-	};	
+        0xe5, 0x20, 0x58, 0xff, 0xba, 0xbd, 0x00, 0x01, 0x0a, 0x0a, 0x0a, 0x0a, 0x85, 0x2b, 0xaa, 0xbd,
+        0x8e, 0xc0, 0xbd, 0x8c, 0xc0, 0xbd, 0x8a, 0xc0, 0xbd, 0x89, 0xc0, 0xa0, 0x50, 0xbd, 0x80, 0xc0,
+        0x98, 0x29, 0x03, 0x0a, 0x05, 0x2b, 0xaa, 0xbd, 0x81, 0xc0, 0xa9, 0x56, 0xa9, 0x00, 0xea, 0x88,
+        0x10, 0xeb, 0x85, 0x26, 0x85, 0x3d, 0x85, 0x41, 0xa9, 0x08, 0x85, 0x27, 0x18, 0x08, 0xbd, 0x8c,
+        0xc0, 0x10, 0xfb, 0x49, 0xd5, 0xd0, 0xf7, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0xc9, 0xaa, 0xd0, 0xf3,
+        0xea, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0xc9, 0x96, 0xf0, 0x09, 0x28, 0x90, 0xdf, 0x49, 0xad, 0xf0,
+        0x25, 0xd0, 0xd9, 0xa0, 0x03, 0x85, 0x40, 0xbd, 0x8c, 0xc0, 0x10, 0xfb, 0x2a, 0x85, 0x3c, 0xbd,
+        0x8c, 0xc0, 0x10, 0xfb, 0x25, 0x3c, 0x88, 0xd0, 0xec, 0x28, 0xc5, 0x3d, 0xd0, 0xbe, 0xa5, 0x40,
+        0xc5, 0x41, 0xd0, 0xb8, 0xb0, 0xb7, 0xa0, 0x56, 0x84, 0x3c, 0xbc, 0x8c, 0xc0, 0x10, 0xfb, 0x59,
+        0xd6, 0x02, 0xa4, 0x3c, 0x88, 0x99, 0x00, 0x03, 0xd0, 0xee, 0x84, 0x3c, 0xbc, 0x8c, 0xc0, 0x10,
+        0xfb, 0x59, 0xd6, 0x02, 0xa4, 0x3c, 0x91, 0x26, 0xc8, 0xd0, 0xef, 0xbc, 0x8c, 0xc0, 0x10, 0xfb,
+        0x59, 0xd6, 0x02, 0xd0, 0x87, 0xa0, 0x00, 0xa2, 0x56, 0xca, 0x30, 0xfb, 0xb1, 0x26, 0x5e, 0x00,
+        0x03, 0x2a, 0x5e, 0x00, 0x03, 0x2a, 0x91, 0x26, 0xc8, 0xd0, 0xee, 0xe6, 0x27, 0xe6, 0x3d, 0xa5,
+        0x3d, 0xcd, 0x00, 0x08, 0xa6, 0x2b, 0x90, 0xdb, 0x4c, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+    };
 
-	// Constants
-	private static final int NUM_DRIVES = 2;
-	private static final int DOS_NUM_SECTORS = 16;
-	private static final int DOS_NUM_TRACKS = 35;
-	private static final int DOS_TRACK_BYTES = 256 * DOS_NUM_SECTORS;
-	private static final int RAW_TRACK_BYTES = 6656; // TODO 6250 ???
-	
-	// Disk II direct access variables
-	private int drive = 0;
-	private boolean isMotorOn = false;
+    // Constants
+    private static final int NUM_DRIVES = 2;
+    private static final int DOS_NUM_SECTORS = 16;
+    private static final int DOS_NUM_TRACKS = 35;
+    private static final int DOS_TRACK_BYTES = 256 * DOS_NUM_SECTORS;
+    private static final int RAW_TRACK_BYTES = 6656; // TODO 6250 ???
 
-	private byte[][][] disk = new byte[NUM_DRIVES][DOS_NUM_TRACKS][];
-	private boolean[] isWriteProtected = new boolean[NUM_DRIVES];
+    // Disk II direct access variables
+    private int drive = 0;
+    private boolean isMotorOn = false;
 
-	private int currPhysTrack;
-	private int currNibble;
+    private byte[][][] disk = new byte[NUM_DRIVES][DOS_NUM_TRACKS][];
+    private boolean[] isWriteProtected = new boolean[NUM_DRIVES];
 
-	// Caches
-	private int[] driveCurrPhysTrack = new int[NUM_DRIVES];
-	private byte[] realTrack;
-	
-	/*
-	 * Disk II emulation:
-	 *
-	 * C0xD, C0xE -> Read write protect
-	 * C0xE, C0xC -> Read data from disk
-	 * Write data to disk -> C0xF, C0xC
-	 * Write data to disk -> C0xD, C0xC
-	 *
-	 * We use 'fast mode', i.e. no 65(C)02 clock reference
-	 * We use simplified track handling (only adjacent phases)
-	 */
+    private int currPhysTrack;
+    private int currNibble;
 
-	// Internal registers
-	private int latchAddress;
-	private int latchData;
-	private boolean writeMode;
-	
-	// GCR encoding and decoding tables
-	private static final int[] gcrEncodingTable = {
-		0x96, 0x97, 0x9a, 0x9b, 0x9d, 0x9e, 0x9f, 0xa6,
-		0xa7, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb2, 0xb3,
-		0xb4, 0xb5, 0xb6, 0xb7, 0xb9, 0xba, 0xbb, 0xbc,
-		0xbd, 0xbe, 0xbf, 0xcb, 0xcd, 0xce, 0xcf, 0xd3,
-		0xd6, 0xd7, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde,
-		0xdf, 0xe5, 0xe6, 0xe7, 0xe9, 0xea, 0xeb, 0xec,
-		0xed, 0xee, 0xef, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
-		0xf7, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
-	};
-//	private int[] gcrDecodingTable = new int[256];
-	private int[] gcrSwapBit = {0, 2, 1, 3};
-	private int[] gcrBuffer = new int[256];
-	private int[] gcrBuffer2 = new int[86];
-	
-	// Physical sector to DOS 3.3 logical sector table
-	private static final int[] gcrLogicalSector = {
-		0x0, 0x7, 0xe, 0x6, 0xd, 0x5, 0xc, 0x4,
-		0xb, 0x3, 0xa, 0x2, 0x9, 0x1, 0x8, 0xf
-	};
-	
-	// Temporary variables for conversion
-	private byte[] gcrNibbles = new byte[RAW_TRACK_BYTES];
-	private int gcrNibblesPos;
-	
-	/**
-	 * Constructor
-	 */
-	public DiskII() {
-	    readDisk(null, 0, null, 254, false);
-		readDisk(null, 1, null, 254, false);
-	}
+    // Caches
+    private int[] driveCurrPhysTrack = new int[NUM_DRIVES];
+    private byte[] realTrack;
+
+    /*
+     * Disk II emulation:
+     *
+     * C0xD, C0xE -> Read write protect
+     * C0xE, C0xC -> Read data from disk
+     * Write data to disk -> C0xF, C0xC
+     * Write data to disk -> C0xD, C0xC
+     *
+     * We use 'fast mode', i.e. no 65(C)02 clock reference
+     * We use simplified track handling (only adjacent phases)
+     */
+
+    // Internal registers
+    private int latchAddress;
+    private int latchData;
+    private boolean writeMode;
+
+    // GCR encoding and decoding tables
+    private static final int[] gcrEncodingTable = {
+        0x96, 0x97, 0x9a, 0x9b, 0x9d, 0x9e, 0x9f, 0xa6,
+        0xa7, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb2, 0xb3,
+        0xb4, 0xb5, 0xb6, 0xb7, 0xb9, 0xba, 0xbb, 0xbc,
+        0xbd, 0xbe, 0xbf, 0xcb, 0xcd, 0xce, 0xcf, 0xd3,
+        0xd6, 0xd7, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde,
+        0xdf, 0xe5, 0xe6, 0xe7, 0xe9, 0xea, 0xeb, 0xec,
+        0xed, 0xee, 0xef, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
+        0xf7, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+    };
+//    private int[] gcrDecodingTable = new int[256];
+    private int[] gcrSwapBit = {0, 2, 1, 3};
+    private int[] gcrBuffer = new int[256];
+    private int[] gcrBuffer2 = new int[86];
+
+    // Physical sector to DOS 3.3 logical sector table
+    private static final int[] gcrLogicalSector = {
+        0x0, 0x7, 0xe, 0x6, 0xd, 0x5, 0xc, 0x4,
+        0xb, 0x3, 0xa, 0x2, 0x9, 0x1, 0x8, 0xf
+    };
+
+    // Temporary variables for conversion
+    private byte[] gcrNibbles = new byte[RAW_TRACK_BYTES];
+    private int gcrNibblesPos;
+
+    /**
+     * Constructor
+     */
+    public DiskII() {
+        readDisk(null, 0, null, 254, false);
+        readDisk(null, 1, null, 254, false);
+    }
 
     /**
      * I/O read
-     * 
+     *
      * @param address Address
      */
-	public int ioRead(int address) {
-		int phase;
-		
-		switch (address & 0xf) {
-			case 0x0:
-			case 0x2:			
-			case 0x4:
-			case 0x6:
-				// Q0, Q1, Q2, Q3 off
-				break;
-			case 0x1:
-				// Q0 on
-				phase = currPhysTrack & 3;
-				if (phase == 1) {
-					if (currPhysTrack > 0) {
-						currPhysTrack--;
-					}
-				} else if (phase == 3) {
-					if (currPhysTrack < ((2 * DOS_NUM_TRACKS) - 1)) {
-						currPhysTrack++;
-					}
-				}
-				realTrack = disk[drive][currPhysTrack >> 1];
-				break;
-			case 0x3:
-				// Q1 on
-				phase = currPhysTrack & 3;
-				if (phase == 2) {
-					if (currPhysTrack > 0) {
-						currPhysTrack--;
-					}
-				} else if (phase == 0) {
-					if (currPhysTrack < ((2 * DOS_NUM_TRACKS) - 1)) {
-						currPhysTrack++;
-					}
-				}
-				realTrack = disk[drive][currPhysTrack >> 1];
-				break;
-			case 0x5:
-				// Q2 on
-				phase = currPhysTrack & 3;
-				if (phase == 3) {
-					if (currPhysTrack > 0) {
-						currPhysTrack--;
-					}
-				} else if (phase == 1) {
-					if (currPhysTrack < ((2 * DOS_NUM_TRACKS) - 1)) {
-						currPhysTrack++;
-					}
-				}
-				realTrack = disk[drive][currPhysTrack >> 1];
-				break;
-			case 0x7:
-				// Q3 on
-				phase = currPhysTrack & 3;
-				if (phase == 0) {
-					if (currPhysTrack > 0) {
-						currPhysTrack--;
-					}
-				} else if (phase == 2) {
-					if (currPhysTrack < ((2 * DOS_NUM_TRACKS) - 1)) {
-						currPhysTrack++;
-					}
-				}
-				realTrack = disk[drive][currPhysTrack >> 1];
-				break;
-			case 0x8:
-				// Motor off
-				isMotorOn = false;
-				break;
-			case 0x9:
-				// Motor on
-				isMotorOn = true;
-				break;
-			case 0xa:
-				// Drive 1
-				driveCurrPhysTrack[drive] = currPhysTrack;
-				drive = 0;
-				currPhysTrack = driveCurrPhysTrack[drive];
+    public int ioRead(int address) {
+        int phase;
 
-				realTrack = disk[drive][currPhysTrack >> 1];
-				break;
-			case 0xb:
-				// Drive 2
-				driveCurrPhysTrack[drive] = currPhysTrack;
-				drive = 1;
-				currPhysTrack = driveCurrPhysTrack[drive];
+        switch (address & 0xf) {
+        case 0x0:
+        case 0x2:
+            case 0x4:
+            case 0x6:
+                // Q0, Q1, Q2, Q3 off
+                break;
+            case 0x1:
+                // Q0 on
+                phase = currPhysTrack & 3;
+                if (phase == 1) {
+                    if (currPhysTrack > 0) {
+                        currPhysTrack--;
+                    }
+                } else if (phase == 3) {
+                    if (currPhysTrack < ((2 * DOS_NUM_TRACKS) - 1)) {
+                        currPhysTrack++;
+                    }
+                }
+                realTrack = disk[drive][currPhysTrack >> 1];
+                break;
+            case 0x3:
+                // Q1 on
+                phase = currPhysTrack & 3;
+                if (phase == 2) {
+                    if (currPhysTrack > 0) {
+                        currPhysTrack--;
+                    }
+                } else if (phase == 0) {
+                    if (currPhysTrack < ((2 * DOS_NUM_TRACKS) - 1)) {
+                        currPhysTrack++;
+                    }
+                }
+                realTrack = disk[drive][currPhysTrack >> 1];
+                break;
+            case 0x5:
+                // Q2 on
+                phase = currPhysTrack & 3;
+                if (phase == 3) {
+                    if (currPhysTrack > 0) {
+                        currPhysTrack--;
+                    }
+                } else if (phase == 1) {
+                    if (currPhysTrack < ((2 * DOS_NUM_TRACKS) - 1)) {
+                        currPhysTrack++;
+                    }
+                }
+                realTrack = disk[drive][currPhysTrack >> 1];
+                break;
+            case 0x7:
+                // Q3 on
+                phase = currPhysTrack & 3;
+                if (phase == 0) {
+                    if (currPhysTrack > 0) {
+                        currPhysTrack--;
+                    }
+                } else if (phase == 2) {
+                    if (currPhysTrack < ((2 * DOS_NUM_TRACKS) - 1)) {
+                        currPhysTrack++;
+                    }
+                }
+                realTrack = disk[drive][currPhysTrack >> 1];
+                break;
+            case 0x8:
+                // Motor off
+                isMotorOn = false;
+                break;
+            case 0x9:
+                // Motor on
+                isMotorOn = true;
+                break;
+            case 0xa:
+                // Drive 1
+                driveCurrPhysTrack[drive] = currPhysTrack;
+                drive = 0;
+                currPhysTrack = driveCurrPhysTrack[drive];
 
-				realTrack = disk[drive][currPhysTrack >> 1];
-				break;
-			case 0xc:
-				return ioLatchC();
-			case 0xd:
-				ioLatchD(0xff);
-				break;
-			case 0xe:
-				return ioLatchE();
-			case 0xf:
-				ioLatchF(0xff);
-				break;
-		}
-		
-		return rand.nextInt(256);
+                realTrack = disk[drive][currPhysTrack >> 1];
+                break;
+            case 0xb:
+                // Drive 2
+                driveCurrPhysTrack[drive] = currPhysTrack;
+                drive = 1;
+                currPhysTrack = driveCurrPhysTrack[drive];
+
+                realTrack = disk[drive][currPhysTrack >> 1];
+                break;
+            case 0xc:
+                return ioLatchC();
+            case 0xd:
+                ioLatchD(0xff);
+                break;
+            case 0xe:
+                return ioLatchE();
+            case 0xf:
+                ioLatchF(0xff);
+                break;
+        }
+
+        return rand.nextInt(256);
     }
 
     /**
      * I/O write
-     * 
+     *
      * @param address Address
      */
-	public void ioWrite(int address, int value) {
-		switch (address & 0xf) {
-		case 0x0:
-		case 0x1:
-		case 0x2:			
-		case 0x3:
-		case 0x4:
-		case 0x5:
-		case 0x6:
-		case 0x7:
-		case 0x8:
-		case 0x9:
-		case 0xa:
-		case 0xb:
-			ioRead(address);
-			break;
-		case 0xc:
-			ioLatchC();
-			break;
-		case 0xd:
-			ioLatchD(value);
-			break;
-		case 0xe:
-			ioLatchE();
-			break;
-		case 0xf:
-			ioLatchF(value);
-			break;
-		}
+    public void ioWrite(int address, int value) {
+        switch (address & 0xf) {
+        case 0x0:
+        case 0x1:
+        case 0x2:
+        case 0x3:
+        case 0x4:
+        case 0x5:
+        case 0x6:
+        case 0x7:
+        case 0x8:
+        case 0x9:
+        case 0xa:
+        case 0xb:
+            ioRead(address);
+            break;
+        case 0xc:
+            ioLatchC();
+            break;
+        case 0xd:
+            ioLatchD(value);
+            break;
+        case 0xe:
+            ioLatchE();
+            break;
+        case 0xf:
+            ioLatchF(value);
+            break;
+        }
     }
 
     /**
      * Memory read
-     * 
+     *
      * @param address Address
      */
     public int memoryRead(int address) {
-		return rom[address & 0xff];
+        return rom[address & 0xff];
     }
 
-	/**
-	 * Reset peripheral
-	 */
-	public void reset() {
-		ioRead(0x8);
-	}
+    /**
+     * Reset peripheral
+     */
+    public void reset() {
+        ioRead(0x8);
+    }
 
     /**
      * Loads a disk
-     * 
+     *
      * @param resource filename
      * @param drive Disk II drive
      * @throws IllegalStateException
      */
-	public void readDisk(AppleIIGo.Dao dao, int drive, String resource, int volume, boolean isWriteProtected) {
-		byte[] track = new byte[RAW_TRACK_BYTES];
+    public void readDisk(AppleIIGo.Dao dao, int drive, String resource, int volume, boolean isWriteProtected) {
+        byte[] track = new byte[RAW_TRACK_BYTES];
 
-		boolean isNib = false;
+        boolean isNib = false;
         if (resource != null) {
             dao.openInputStream(resource);
             if (resource.toLowerCase().endsWith(".nib")) {
@@ -284,236 +284,236 @@ System.err.println("DRIVE[" + drive + "]: NIB");
 System.err.println("DRIVE[" + drive + "]: DSK");
             }
         }
-		for (int trackNum = 0; trackNum < DOS_NUM_TRACKS; trackNum++) {
-			disk[drive][trackNum] = new byte[RAW_TRACK_BYTES];
+        for (int trackNum = 0; trackNum < DOS_NUM_TRACKS; trackNum++) {
+            disk[drive][trackNum] = new byte[RAW_TRACK_BYTES];
 
-			if (resource != null) {
-			    if (isNib) {
-	                dao.read(disk[drive][trackNum], 0, RAW_TRACK_BYTES);
-			    } else {
-	                dao.read(track, 0, DOS_TRACK_BYTES);
-			        trackToNibbles(track, disk[drive][trackNum], volume, trackNum);
-			    }
-			}
-		}
+            if (resource != null) {
+                if (isNib) {
+                    dao.read(disk[drive][trackNum], 0, RAW_TRACK_BYTES);
+                } else {
+                    dao.read(track, 0, DOS_TRACK_BYTES);
+                    trackToNibbles(track, disk[drive][trackNum], volume, trackNum);
+                }
+            }
+        }
         if (resource != null) {
             dao.closeInputStream();
         }
 
-		this.realTrack = disk[drive][currPhysTrack >> 1];
-		this.isWriteProtected[drive] = isWriteProtected;
-	}
+        this.realTrack = disk[drive][currPhysTrack >> 1];
+        this.isWriteProtected[drive] = isWriteProtected;
+    }
 
     /**
      * Writes a disk
-     * 
+     *
      * @param resource filename
      * @param drive Disk II drive
      */
-	public void writeDisk(int drive, String resource) {
-	}
+    public void writeDisk(int drive, String resource) {
+    }
 
-	/**
- 	 * Motor on indicator
-	 */
-	public boolean isMotorOn() {
-		return isMotorOn;
-	}
+    /**
+      * Motor on indicator
+     */
+    public boolean isMotorOn() {
+        return isMotorOn;
+    }
 
     /**
      * I/O read Latch C
-     * 
+     *
      * @param address Address
      */
-	private int ioLatchC() {
-		if (writeMode) {
-			// Write data: C0xD, C0xC
-			realTrack[currNibble] = (byte) latchData;
-		} else {
-			// Read data: C0xE, C0xC
-			latchData = (realTrack[currNibble] & 0xff);
-		}
+    private int ioLatchC() {
+        if (writeMode) {
+            // Write data: C0xD, C0xC
+            realTrack[currNibble] = (byte) latchData;
+        } else {
+            // Read data: C0xE, C0xC
+            latchData = (realTrack[currNibble] & 0xff);
+        }
 
-		currNibble++;
-		if (currNibble >= RAW_TRACK_BYTES) {
-			currNibble = 0;
-		}
+        currNibble++;
+        if (currNibble >= RAW_TRACK_BYTES) {
+            currNibble = 0;
+        }
 
-		latchAddress = 0xc;
-		return latchData;
-	}
+        latchAddress = 0xc;
+        return latchData;
+    }
 
     /**
      * I/O write Latch D
-     * 
+     *
      * @param address Address
      */
-	private void ioLatchD(int value) {
-		// Prepare write
-		writeMode = true;
-		latchData = value;
-		latchAddress = 0xd;
-	}
+    private void ioLatchD(int value) {
+        // Prepare write
+        writeMode = true;
+        latchData = value;
+        latchAddress = 0xd;
+    }
 
     /**
      * I/O read Latch E
-     * 
+     *
      * @param address Address
      */
-	private int ioLatchE() {
-		// Read write-protect: C0xD, C0xE
-		if (latchAddress == 0xd) {
-			latchAddress = 0xe;
-			return isWriteProtected[drive] ? 0x80 : 0x00;
-		}
+    private int ioLatchE() {
+        // Read write-protect: C0xD, C0xE
+        if (latchAddress == 0xd) {
+            latchAddress = 0xe;
+            return isWriteProtected[drive] ? 0x80 : 0x00;
+        }
 
-		writeMode = false;
-		latchAddress = 0xe;
-		return 0x3c;
-	}
+        writeMode = false;
+        latchAddress = 0xe;
+        return 0x3c;
+    }
 
     /**
      * I/O write Latch F
-     * 
+     *
      * @param address Address
      */
-	private void ioLatchF(int value) {
-		// Prepare write
-		writeMode = true;
-		latchData = value;
-		latchAddress = 0xf;
-	}
+    private void ioLatchF(int value) {
+        // Prepare write
+        writeMode = true;
+        latchData = value;
+        latchAddress = 0xf;
+    }
 
-	/*
-	 * TRACK CONVERSION ROUTINES
-	 */
+    /*
+     * TRACK CONVERSION ROUTINES
+     */
 
     /**
      * Writes a nibble
-     * 
+     *
      * @param value Value
      */
-	private final void gcrWriteNibble(int value) {
-		gcrNibbles[gcrNibblesPos] = (byte) value;
-		gcrNibblesPos++;
-	}
+    private final void gcrWriteNibble(int value) {
+        gcrNibbles[gcrNibblesPos] = (byte) value;
+        gcrNibblesPos++;
+    }
 
     /**
      * Writes sync bits
-     * 
+     *
      * @param length Number of bits
      */
-	private final void writeSync(int length) {
-		while(length > 0) {
-			length--;
-			gcrWriteNibble(0xff);
-		}
-	}
+    private final void writeSync(int length) {
+        while(length > 0) {
+            length--;
+            gcrWriteNibble(0xff);
+        }
+    }
 
     /**
      * Write an FM encoded value, used in writing address fields
-     * 
+     *
      * @param value Value
      */
-	private final void encode44(int value) {
-		gcrWriteNibble((value >> 1) | 0xaa);
-		gcrWriteNibble(value | 0xaa);
-	}
+    private final void encode44(int value) {
+        gcrWriteNibble((value >> 1) | 0xaa);
+        gcrWriteNibble(value | 0xaa);
+    }
 
     /**
      * Encode in 6:2
-     * 
+     *
      * @param track Sectorized track data
      * @param offset Offset in this data
      */
-	private void encode62(byte[] track, int offset) {
-		// 86 * 3 = 258, so the first two byte are encoded twice
-		gcrBuffer2[0] = gcrSwapBit[track[offset + 1] & 0x03];
-		gcrBuffer2[1] = gcrSwapBit[track[offset] & 0x03];
+    private void encode62(byte[] track, int offset) {
+        // 86 * 3 = 258, so the first two byte are encoded twice
+        gcrBuffer2[0] = gcrSwapBit[track[offset + 1] & 0x03];
+        gcrBuffer2[1] = gcrSwapBit[track[offset] & 0x03];
 
-		// Save higher 6 bits in gcrBuffer and lower 2 bits in gcrBuffer2
-		for(int i = 255, j = 2; i >= 0; i--, j = j == 85 ? 0: j + 1) {
-		   gcrBuffer2[j] = ((gcrBuffer2[j] << 2) | gcrSwapBit[track[offset + i] & 0x03]);
-		   gcrBuffer[i] = (track[offset + i] & 0xff)  >> 2;
-		}
-		 
-		// Clear off higher 2 bits of GCR_buffer2 set in the last call
-		for(int i = 0; i < 86; i++) {
-		   gcrBuffer2[i] &= 0x3f;
-		}
-	}
+        // Save higher 6 bits in gcrBuffer and lower 2 bits in gcrBuffer2
+        for(int i = 255, j = 2; i >= 0; i--, j = j == 85 ? 0: j + 1) {
+           gcrBuffer2[j] = ((gcrBuffer2[j] << 2) | gcrSwapBit[track[offset + i] & 0x03]);
+           gcrBuffer[i] = (track[offset + i] & 0xff)  >> 2;
+        }
+
+        // Clear off higher 2 bits of GCR_buffer2 set in the last call
+        for(int i = 0; i < 86; i++) {
+           gcrBuffer2[i] &= 0x3f;
+        }
+    }
 
     /**
      * Write address field
-     * 
+     *
      * @param track Sectorized track data
      * @param offset Offset in this data
      */
-	private final void writeAddressField(int volumeNum, int trackNum, int sectorNum) {
-		// Write address mark
-		gcrWriteNibble(0xd5);
-		gcrWriteNibble(0xaa);
-		gcrWriteNibble(0x96);
-		 
-		// Write volume, trackNum, sector & checksum
-		encode44(volumeNum);
-		encode44(trackNum);
-		encode44(sectorNum);
-		encode44(volumeNum ^ trackNum ^ sectorNum);
-		 
-		// Write epilogue
-		gcrWriteNibble(0xde);
-		gcrWriteNibble(0xaa);
-		gcrWriteNibble(0xeb);
-	}
-	
-	/**
- 	 * Write data field
-	 */
-	private void writeDataField() {
-		int last = 0;
-		int checksum;
+    private final void writeAddressField(int volumeNum, int trackNum, int sectorNum) {
+        // Write address mark
+        gcrWriteNibble(0xd5);
+        gcrWriteNibble(0xaa);
+        gcrWriteNibble(0x96);
 
-		// Write prologue
-		gcrWriteNibble(0xd5);
-		gcrWriteNibble(0xaa);
-		gcrWriteNibble(0xad);
+        // Write volume, trackNum, sector & checksum
+        encode44(volumeNum);
+        encode44(trackNum);
+        encode44(sectorNum);
+        encode44(volumeNum ^ trackNum ^ sectorNum);
 
-		// Write GCR encoded data
-		for (int i = 0x55; i >= 0; i--) {
-			checksum = last ^ gcrBuffer2[i];
-			gcrWriteNibble(gcrEncodingTable[checksum]);
-			last = gcrBuffer2[i];
-		}
-		for (int i = 0; i < 256; i++) {
-			checksum = last ^ gcrBuffer[i];
-			gcrWriteNibble(gcrEncodingTable[checksum]);
-			last = gcrBuffer[i];
-		}
+        // Write epilogue
+        gcrWriteNibble(0xde);
+        gcrWriteNibble(0xaa);
+        gcrWriteNibble(0xeb);
+    }
 
-		// Write checksum
-		gcrWriteNibble(gcrEncodingTable[last]);
+    /**
+      * Write data field
+     */
+    private void writeDataField() {
+        int last = 0;
+        int checksum;
 
-		// Write epilogue
-		gcrWriteNibble(0xde);
-		gcrWriteNibble(0xaa);
-		gcrWriteNibble(0xeb);
-	}
+        // Write prologue
+        gcrWriteNibble(0xd5);
+        gcrWriteNibble(0xaa);
+        gcrWriteNibble(0xad);
 
-	/**
- 	 * Converts a track to nibbles
-	 */
-	private void trackToNibbles(byte[] track, byte[] nibbles, int volumeNum, int trackNum) {
-		this.gcrNibbles = nibbles;
-		gcrNibblesPos = 0;
+        // Write GCR encoded data
+        for (int i = 0x55; i >= 0; i--) {
+            checksum = last ^ gcrBuffer2[i];
+            gcrWriteNibble(gcrEncodingTable[checksum]);
+            last = gcrBuffer2[i];
+        }
+        for (int i = 0; i < 256; i++) {
+            checksum = last ^ gcrBuffer[i];
+            gcrWriteNibble(gcrEncodingTable[checksum]);
+            last = gcrBuffer[i];
+        }
 
-		for (int sectorNum = 0; sectorNum < DOS_NUM_SECTORS; sectorNum++) {
-			encode62(track, gcrLogicalSector[sectorNum] << 8);
-			writeSync(12);
-			writeAddressField(volumeNum, trackNum, sectorNum);
-			writeSync(8);
-			writeDataField();
-		}
-		writeSync(RAW_TRACK_BYTES - gcrNibblesPos);
-	}
+        // Write checksum
+        gcrWriteNibble(gcrEncodingTable[last]);
+
+        // Write epilogue
+        gcrWriteNibble(0xde);
+        gcrWriteNibble(0xaa);
+        gcrWriteNibble(0xeb);
+    }
+
+    /**
+      * Converts a track to nibbles
+     */
+    private void trackToNibbles(byte[] track, byte[] nibbles, int volumeNum, int trackNum) {
+        this.gcrNibbles = nibbles;
+        gcrNibblesPos = 0;
+
+        for (int sectorNum = 0; sectorNum < DOS_NUM_SECTORS; sectorNum++) {
+            encode62(track, gcrLogicalSector[sectorNum] << 8);
+            writeSync(12);
+            writeAddressField(volumeNum, trackNum, sectorNum);
+            writeSync(8);
+            writeDataField();
+        }
+        writeSync(RAW_TRACK_BYTES - gcrNibblesPos);
+    }
 }
diff --git a/src/main/java/vavi/apps/appleii/Em6502.java b/src/main/java/vavi/apps/appleii/Em6502.java
index e66170f..0f0227f 100644
--- a/src/main/java/vavi/apps/appleii/Em6502.java
+++ b/src/main/java/vavi/apps/appleii/Em6502.java
@@ -12,1637 +12,1637 @@ package vavi.apps.appleii;
 
 
 public class Em6502 {
-	/**
-	 * Base memory (including zero page and stack)
-	 */
-	public byte[] mem = null;
-
-	/**
-	 * Generic memory read & write (0x0000-0xffff)
-	 */
-	protected int memoryRead(int addr) {
-		return mem[addr] & 0xff;
-	}
-
-	protected void memoryWrite(int addr, int value) {
-		mem[addr] = (byte) value;
-	}
-
-	/*
-	 * Zero page read & write
-	 */
-	private final int zeroPageRead(int addr) {
-		return mem[addr] & 0xff;
-	}
-
-	private final void zeroPageWrite(int addr, int value) {
-		mem[addr] = (byte) value;
-	}
-
-	/*
-	 * Userspace interrupts
-	 */
-	public final void assertReset() {
-		exceptionRegister |= SIG_6502_RESET;
-	}
-
-	public final void assertNMI() {
-		exceptionRegister |= SIG_6502_NMI;
-	}
-
-	public final void assertIRQ() {
-		exceptionRegister |= SIG_6502_IRQ;
-	}
-	
-	/*
-	 * Userspace interrupt handlers
-	 */
-	protected void onReset() {
-	}
-
-	protected void onNMI() {
-	}
-
-	protected void onIRQ() {
-	}
-
-	/**
-	 * CPU Registers
-	 */
-	public int A, X, Y, P, S, PC;
-
-	/**
-	 * CPU Clock
-	 */
-	protected int clock;
-
-	/*
-	 * CPU Flags
-	 */
-	public static final int FLAG_C = (1 << 0);
-	public static final int FLAG_Z = (1 << 1);
-	public static final int FLAG_I = (1 << 2);
-	public static final int FLAG_D = (1 << 3);
-	public static final int FLAG_B = (1 << 4);
-	public static final int FLAG_V = (1 << 6);
-	public static final int FLAG_N = (1 << 7);
-	/*
-	 *	owing to a bug in 6502, the bit 5 must be always 1;
-	 *	otherwise, programs like DOS 3.3 will break down
-	 *	see instructions in $9FF4-$9FF5 of DOS 3.3
-	 */
-	
-	/*
-	 * CPU Signals
+    /**
+     * Base memory (including zero page and stack)
      */
-	private int exceptionRegister = 0;
+    public byte[] mem = null;
 
- 	public static final int SIG_6502_RESET = (1 << 0);
-	public static final int SIG_6502_NMI = (1 << 1);
-	public static final int SIG_6502_IRQ = (1 << 2);
+    /**
+     * Generic memory read & write (0x0000-0xffff)
+     */
+    protected int memoryRead(int addr) {
+        return mem[addr] & 0xff;
+    }
 
-	/**
-	 * CPU IRQ State
-	 */ 
-	private int pendingIRQ;
-	
-	/*
-	 * Emulator registers
-	 */
-	private int easp1, easp2;
-	private int operandAddress;
-	private int opcode;
-	private int operand;
-	private int result;
-	private int NZFlags;
-	
-	/*
-	 * ALU look up tables
-	 */
-	private int BCDTableAdd[];	// addition correction
-	private int BCDTableSub[];	// subtraction correction
+    protected void memoryWrite(int addr, int value) {
+        mem[addr] = (byte) value;
+    }
 
-	/**
-	 * Constructor
-	 */
-	public Em6502() {
-		// Init BCD tables
-		BCDTableAdd = new int[512];
-		BCDTableSub = new int[512];
-			
-		for (int i = 0; i < 512; i++) {
-			BCDTableAdd[i] = ((i & 0x0f) <= 0x09) ? i : (i + 0x06);
-			BCDTableAdd[i] += ((BCDTableAdd[i] & 0xf0) <= 0x90) ? 0 : 0x60;
-			if (BCDTableAdd[i] > 0x1ff) {
-				BCDTableAdd[i] -= 0x100;
-			}
-			  
-			BCDTableSub[i] = ((i & 0x0f) <= 0x09) ? i : (i - 0x06);
-			BCDTableSub[i] -= ((BCDTableSub[i] & 0xf0) <= 0x90) ? 0 : 0x60;
-		}
-	}
-	
-	/*
-	 * Stack macros
-	 */
-	private final int pop() {
-		S++;
-		S &= 0xff;
-		return (mem[S | 0x100] & 0xff);
-	}
+    /*
+     * Zero page read & write
+     */
+    private final int zeroPageRead(int addr) {
+        return mem[addr] & 0xff;
+    }
 
-	private final void push(int value) {
-		mem[S | 0x100] = (byte) value;
-		S--;
-		S &= 0xff;
-	}
+    private final void zeroPageWrite(int addr, int value) {
+        mem[addr] = (byte) value;
+    }
 
-	/*
-	 * Macros for P flags
-	 */
-	private final void setN(boolean b) {if (b) P |= FLAG_N; else P &= ~FLAG_N;}
-	private final void setV(boolean b) {if (b) P |= FLAG_V; else P &= ~FLAG_V;}
-	private final void setB(boolean b) {if (b) P |= FLAG_B; else P &= ~FLAG_B;}
-	private final void setD(boolean b) {if (b) P |= FLAG_D; else P &= ~FLAG_D;}
-	private final void setI(boolean b) {if (b) P |= FLAG_I; else P &= ~FLAG_I;}
-	private final void setZ(boolean b) {if (b) P |= FLAG_Z; else P &= ~FLAG_Z;}
-	private final void setC(boolean b) {if (b) P |= FLAG_C; else P &= ~FLAG_C;}
-	private final boolean getN() {return ((P & FLAG_N) != 0);}
-	private final boolean getV() {return ((P & FLAG_V) != 0);}
-	private final boolean getB() {return ((P & FLAG_B) != 0);}
-	private final boolean getD() {return ((P & FLAG_D) != 0);}
-	private final boolean getI() {return ((P & FLAG_I) != 0);}
-	private final boolean getZ() {return ((P & FLAG_Z) != 0);}
-	private final boolean getC() {return ((P & FLAG_C) != 0);}
+    /*
+     * Userspace interrupts
+     */
+    public final void assertReset() {
+        exceptionRegister |= SIG_6502_RESET;
+    }
 
-	/*
-	 * Fast condition codes. Instead of using bits to encode condition codes,
-	 * recent ALU results are cached to that the condition codes can be
-	 * handled more easily by the emulator's native hardware.
-	 */
-	private final boolean getFN() {return ((NZFlags & 0x280) != 0);}
-	private final boolean getFNotN() {return ((NZFlags & 0x280) == 0);}
-	private final boolean getFZ() {return ((NZFlags & 0xff) == 0);}
-	private final boolean getFNotZ() {return ((NZFlags & 0xff) != 0);}
-	private final void setFNZ(boolean n, boolean z) {NZFlags = ((n) ? 0x200 : 0x00) | ((z) ? 0x00 : 0x01);}
-	private final boolean getFC() {return (result >> 8) != 0;}
-	private final boolean getFNotC() {return (result >> 8) == 0;}
-	private final int getFC_() {return result >> 8;}
-	private final void setFC(boolean c) {result = (c ? 0x100 : 0x00);}
+    public final void assertNMI() {
+        exceptionRegister |= SIG_6502_NMI;
+    }
 
-	/**
-	 * Macro for page crossing cycle regulation
-	 */
-	private final void checkCrossPage(int addr, int offset) {
-		if ((((addr + offset) ^ addr) & 0xff00) != 0) {
-		    clock++;
-		}
-	}
-	
-	/*
-	 * Macros for effective address calculation 
-	 * (Macros whose names end with NC do not check for page crossing)
-	 */
-	private final int eaimm() {
-		easp1 = memoryRead(PC);	PC++; return easp1;
-	}
+    public final void assertIRQ() {
+        exceptionRegister |= SIG_6502_IRQ;
+    }
 
-	private final int eazp() {
-		easp1 = memoryRead(PC); PC++; return easp1;
-	}
+    /*
+     * Userspace interrupt handlers
+     */
+    protected void onReset() {
+    }
 
-	private final int eazpx() {
-		easp1 = (memoryRead(PC) + X) & 0xff; PC++; return easp1;
-	}
+    protected void onNMI() {
+    }
 
-	private final int eazpy() {
-		easp1 = (memoryRead(PC) + Y) & 0xff; PC++; return easp1;
-	}
+    protected void onIRQ() {
+    }
 
-	private final int eaabs() {
-		easp1 = memoryRead(PC);	PC++;
-		easp1 += (memoryRead(PC) << 8); PC++;
-		return easp1;
-	}
+    /**
+     * CPU Registers
+     */
+    public int A, X, Y, P, S, PC;
 
-	private final int earel() {
-//		easp1 = memoryRead(PC); PC++;
-//		return ((easp1 & 0x80) != 0) ? easp1 - 256 : easp1;
-		easp1 = (byte) memoryRead(PC); PC++; return easp1;
-	}
+    /**
+     * CPU Clock
+     */
+    protected int clock;
 
-	private final int eaabsx() {
-		// No cross page check...
-		// easp1 = eaabs();
-		// checkCrossPage(easp1, X);
-		// return easp1 + X;
-		return eaabs() + X;
-	}
+    /*
+     * CPU Flags
+     */
+    public static final int FLAG_C = (1 << 0);
+    public static final int FLAG_Z = (1 << 1);
+    public static final int FLAG_I = (1 << 2);
+    public static final int FLAG_D = (1 << 3);
+    public static final int FLAG_B = (1 << 4);
+    public static final int FLAG_V = (1 << 6);
+    public static final int FLAG_N = (1 << 7);
+    /*
+     *    owing to a bug in 6502, the bit 5 must be always 1;
+     *    otherwise, programs like DOS 3.3 will break down
+     *    see instructions in $9FF4-$9FF5 of DOS 3.3
+     */
 
-	private final int eaabsxNC() {
-		return eaabs() + X;
-	}
+    /*
+     * CPU Signals
+     */
+    private int exceptionRegister = 0;
 
-	private final int eaabsy() {
-		// No cross page check...
-		// easp1 = eaabs();
-		// checkCrossPage(easp1, Y);
-		// return easp1 + Y;
-		return eaabs() + Y;
-	}
+     public static final int SIG_6502_RESET = (1 << 0);
+    public static final int SIG_6502_NMI = (1 << 1);
+    public static final int SIG_6502_IRQ = (1 << 2);
 
-	private final int eaabsyNC() {
-		return eaabs() + Y;
-	}
+    /**
+     * CPU IRQ State
+     */
+    private int pendingIRQ;
 
-	/*
-	 * Indirect addressing
-	 */
-	private final int eaabsind() {
-		easp1 = eaabs();
-		easp2 = memoryRead(easp1);
-		return easp2 + (memoryRead(easp1 + 1) << 8);
-	}
+    /*
+     * Emulator registers
+     */
+    private int easp1, easp2;
+    private int operandAddress;
+    private int opcode;
+    private int operand;
+    private int result;
+    private int NZFlags;
 
-	private final int eazpxind() {
-		easp1 = eazpx();
-		easp2 = zeroPageRead(easp1);
-		return easp2 + (zeroPageRead((easp1 + 1) & 0xff) << 8);
-	}
+    /*
+     * ALU look up tables
+     */
+    private int BCDTableAdd[];    // addition correction
+    private int BCDTableSub[];    // subtraction correction
 
-	private final int eazpindy() {
-		easp1 = eaimm();
-		easp2 = zeroPageRead(easp1);
-		// No cross page check...
-		// easp2 += (zeroPageRead((easp1 + 1) & 0xff) << 8);
-		// checkCrossPage(easp2,Y);
-		// return easp2 + Y;
-		return easp2 + (zeroPageRead((easp1 + 1) & 0xff) << 8) + Y;
-	}
+    /**
+     * Constructor
+     */
+    public Em6502() {
+        // Init BCD tables
+        BCDTableAdd = new int[512];
+        BCDTableSub = new int[512];
 
-	private final int eazpindyNC() {
-		easp1 = eaimm();
-		easp2 = zeroPageRead(easp1);
-		return easp2 + (zeroPageRead((easp1 + 1) & 0xff) << 8) + Y;
-	}
+        for (int i = 0; i < 512; i++) {
+            BCDTableAdd[i] = ((i & 0x0f) <= 0x09) ? i : (i + 0x06);
+            BCDTableAdd[i] += ((BCDTableAdd[i] & 0xf0) <= 0x90) ? 0 : 0x60;
+            if (BCDTableAdd[i] > 0x1ff) {
+                BCDTableAdd[i] -= 0x100;
+            }
 
-	/*
-	 * New 65C02 addressing mode
-	 */
-	private final int eazpind() {
-		easp1 = eazp();
-		easp2 = zeroPageRead(easp1);
-		return easp2 + (zeroPageRead((easp1 + 1) & 0xff) << 8);
-	}
+            BCDTableSub[i] = ((i & 0x0f) <= 0x09) ? i : (i - 0x06);
+            BCDTableSub[i] -= ((BCDTableSub[i] & 0xf0) <= 0x90) ? 0 : 0x60;
+        }
+    }
 
-	private final int eaabsxind() {
-		easp1 = eaabs();
-		easp2 = memoryRead(easp1);
-		return easp2 + (memoryRead(easp1 + 1) << 8) + X;
-	}
+    /*
+     * Stack macros
+     */
+    private final int pop() {
+        S++;
+        S &= 0xff;
+        return (mem[S | 0x100] & 0xff);
+    }
 
-	/*
-	 * Misc. macros
-	 */
-	private final void adcBCDAdjust() {
-		if (getD()) result = BCDTableAdd[result];
-	}
+    private final void push(int value) {
+        mem[S | 0x100] = (byte) value;
+        S--;
+        S &= 0xff;
+    }
 
-	private final void sbcBCDAdjust() {
-		if (getD()) result = BCDTableSub[result];
-	}
+    /*
+     * Macros for P flags
+     */
+    private final void setN(boolean b) {if (b) P |= FLAG_N; else P &= ~FLAG_N;}
+    private final void setV(boolean b) {if (b) P |= FLAG_V; else P &= ~FLAG_V;}
+    private final void setB(boolean b) {if (b) P |= FLAG_B; else P &= ~FLAG_B;}
+    private final void setD(boolean b) {if (b) P |= FLAG_D; else P &= ~FLAG_D;}
+    private final void setI(boolean b) {if (b) P |= FLAG_I; else P &= ~FLAG_I;}
+    private final void setZ(boolean b) {if (b) P |= FLAG_Z; else P &= ~FLAG_Z;}
+    private final void setC(boolean b) {if (b) P |= FLAG_C; else P &= ~FLAG_C;}
+    private final boolean getN() {return ((P & FLAG_N) != 0);}
+    private final boolean getV() {return ((P & FLAG_V) != 0);}
+    private final boolean getB() {return ((P & FLAG_B) != 0);}
+    private final boolean getD() {return ((P & FLAG_D) != 0);}
+    private final boolean getI() {return ((P & FLAG_I) != 0);}
+    private final boolean getZ() {return ((P & FLAG_Z) != 0);}
+    private final boolean getC() {return ((P & FLAG_C) != 0);}
 
-	private final void branch(int operand) {
-		// No cross page check...
- 		// checkCrossPage(PC, operand);
-		PC += operand;
-		clock++;
-	}
+    /*
+     * Fast condition codes. Instead of using bits to encode condition codes,
+     * recent ALU results are cached to that the condition codes can be
+     * handled more easily by the emulator's native hardware.
+     */
+    private final boolean getFN() {return ((NZFlags & 0x280) != 0);}
+    private final boolean getFNotN() {return ((NZFlags & 0x280) == 0);}
+    private final boolean getFZ() {return ((NZFlags & 0xff) == 0);}
+    private final boolean getFNotZ() {return ((NZFlags & 0xff) != 0);}
+    private final void setFNZ(boolean n, boolean z) {NZFlags = ((n) ? 0x200 : 0x00) | ((z) ? 0x00 : 0x01);}
+    private final boolean getFC() {return (result >> 8) != 0;}
+    private final boolean getFNotC() {return (result >> 8) == 0;}
+    private final int getFC_() {return result >> 8;}
+    private final void setFC(boolean c) {result = (c ? 0x100 : 0x00);}
 
-	/** This executes a single instruction. */
-	private final void executeInstruction() {
-		opcode = memoryRead(PC);
-		PC++;
-		
-		switch(opcode) {
-		case 0x69:	// ADC #imm
-			operand = eaimm();
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x6D:	// ADC abs
-			operand = memoryRead(eaabs());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x65:	// ADC zp
-			operand = zeroPageRead(eazp());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 3;
-			break;
-			
-		case 0x61:	// ADC (zp,X)
-			operand = memoryRead(eazpxind());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 6;
-			break;
-			
-		case 0x71:	// ADC (zp),Y
-			operandAddress = eazpindy();
-			operand = memoryRead(operandAddress);
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x75:	// ADC zp,X
-			operandAddress = eazpx();
-			operand = zeroPageRead(operandAddress);
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x7D:	// ADC abs,X
-			operand = memoryRead(eaabsx());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x79:	// ADC abs,Y
-			operand = memoryRead(eaabsy());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x29:	// AND #imm
-			A &= eaimm();
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x2D:	// AND abs
-			A &= memoryRead(eaabs());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x25:	// AND zp
-			A &= zeroPageRead(eazp());
-			NZFlags = A;
-			clock += 3;
-			break;
-			
-		case 0x21:	// AND (zp,X)
-			A &= memoryRead(eazpxind());
-			NZFlags = A;
-			clock += 6;
-			break;
-			
-		case 0x31:	// AND (zp),Y
-			A &= memoryRead(eazpindy());
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x35:	// AND zp,X
-			A &= zeroPageRead(eazpx());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x3D:	// AND abs,X
-			A &= memoryRead(eaabsx());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x39:	// AND abs,Y
-			A &= memoryRead(eaabsy());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x0E:	// ASL abs
-			operandAddress = eaabs();
-			operand = memoryRead(operandAddress);
-			result = operand << 1;
-			NZFlags = result;
-			memoryWrite(operandAddress, result);
-			clock += 6;
-			break;
-			
-		case 0x06:	// ASL zp
-			operandAddress = eazp();
-			operand = zeroPageRead(operandAddress);
-			result = operand << 1;
-			NZFlags = result;
-			zeroPageWrite(operandAddress, result);
-			clock += 5;
-			break;
-			
-		case 0x0A:	// ASL acc
-			result = A << 1;
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x16:	// ASL zp,X
-			operandAddress = eazpx();
-			operand = zeroPageRead(operandAddress);
-			result = operand << 1;
-			NZFlags = result;
-			zeroPageWrite(operandAddress, result);
-			clock += 6;
-			break;
-			
-		case 0x1E:	// ASL abs,X
-			operandAddress = eaabsx();
-			operand = memoryRead(operandAddress);
-			result = operand << 1;
-			NZFlags = result;
-			memoryWrite(operandAddress, result);
-			clock += 7;
-			break;
-			
-		case 0x90:	// BCC rr
-			operand = earel();
-			clock += 2;
-			if (getFNotC()) 
-				branch(operand);
-			break;
-			
-		case 0xB0:	// BCS rr
-			operand = earel();
-			clock += 2;
-			if (getFC())
-				branch(operand);
-			break;
-			
-		case 0xF0:	// BEQ rr
-			operand = earel();
-			clock += 2;
-			if (getFZ()) 
-				branch(operand);
-			break;
-			
-		case 0x2C:	// BIT abs
-			operand = memoryRead(eaabs());
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			clock += 4;
-			break;
-			
-		case 0x24:	// BIT zp
-			operand = zeroPageRead(eazp());
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			clock += 3;
-			break;
-			
-		case 0x30:	// BMI rr
-			operand = earel();
-			clock += 2;
-			if (getFN()) {
-				branch(operand);
-			}
-			break;
-			
-		case 0xD0:	// BNE rr
-			operand = earel();
-			clock += 2;
-			if (getFNotZ()) { 
-				branch(operand);
-			}
-			break;
-			
-		case 0x10:	// BPL rr
-			operand = earel();
-			clock += 2;
-			if (getFNotN()) { 
-				branch(operand);
-			}
-			break;
-			
-		case 0x00:	// BRK
-			push(PC >> 8);	// save PCH, PCL & P
-			push(PC);
-			setN(getFN());
-			setZ(getFZ());
-			setC(getFC());
-			setB(true);
-			push(P);
-			setI(true);
-			PC = memoryRead(0xfffe);
-			PC |= memoryRead(0xffff) << 8;
-			clock += 7;
-			break;
-			
-		case 0x50:	// BVC rr
-			operand = earel();
-			clock += 2;
-			if (!getV()) {
-				branch(operand);
-			}
-			break;
-			
-		case 0x70:	// BVS rr
-			operand = earel();
-			clock += 2;
-			if (getV()) { 
-				branch(operand);
-			}
-			break;
-			
-		case 0x18:	// CLC rr
-			setFC(false);
-			clock += 2;
-			break;
-			
-		case 0xD8:	// CLD
-			setD(false);
-			clock += 2;
-			break;
-			
-		case 0x58:	// CLI
-			setI(false);
-			clock += 2;
-			if (pendingIRQ > 0) {
-				pendingIRQ--;
-				assertIRQ();
-			}
-			break;
-			
-		case 0xB8:	// CLV
-			setV(false);
-			clock += 2;
-			break;
-			
-		case 0xC9:	// CMP #imm
-			result = 0x100 + A - eaimm();
-			NZFlags = result;
-			clock += 2;
-			break;
-			
-		case 0xCD:	// CMP abs
-			result = 0x100 + A - memoryRead(eaabs());
-			NZFlags = result;
-			clock += 4;
-			break;
-			
-		case 0xC5:	// CMP zp
-			result = 0x100 + A - zeroPageRead(eazp());
-			NZFlags = result;
-			clock += 3;
-			break;
-			
-		case 0xC1:	// CMP (zp,X)
-			result = 0x100 + A - memoryRead(eazpxind());
-			NZFlags = result;
-			clock += 6;
-			break;
-			
-		case 0xD1:	// CMP (zp),Y
-			result = 0x100 + A - memoryRead(eazpindy());
-			NZFlags = result;
-			clock += 5;
-			break;
-			
-		case 0xD5:	// CMP zp,X
-			result = 0x100 + A - zeroPageRead(eazpx());
-			NZFlags = result;
-			clock += 4;
-			break;
-			
-		case 0xDD:	// CMP abs,X
-			result = 0x100 + A - memoryRead(eaabsx());
-			NZFlags = result;
-			clock += 4;
-			break;
-			
-		case 0xD9:	// CMP abs,Y
-			result = 0x100 + A - memoryRead(eaabsy());
-			NZFlags = result;
-			clock += 4;
-			break;
-			
-		case 0xE0:	// CPX #imm
-			result = 0x100 + X - eaimm();
-			NZFlags = result;
-			clock += 2;
-			break;
-			
-		case 0xEC:	// CPX abs
-			result = 0x100 + X - memoryRead(eaabs());
-			NZFlags = result;
-			clock += 4;
-			break;
-			
-		case 0xE4:	// CPX zp
-			result = 0x100 + X - zeroPageRead(eazp());
-			NZFlags = result;
-			clock += 3;
-			break;
-			
-		case 0xC0:	// CPY #imm
-			result = 0x100 + Y - eaimm();
-			NZFlags = result;
-			clock += 2;
-			break;
-			
-		case 0xCC:	// CPY abs
-			result = 0x100 + Y - memoryRead(eaabs());
-			NZFlags = result;
-			clock += 4;
-			break;
-			
-		case 0xC4:	// CPY zp
-			result = 0x100+ Y - zeroPageRead(eazp());
-			NZFlags = result;
-			clock += 3;
-			break;
-			
-		case 0xCE:	// DEC abs
-			operandAddress = eaabs();
-			operand = memoryRead(operandAddress);
-			NZFlags = operand + 0xff;
-			memoryWrite(operandAddress, NZFlags);
-			clock += 6;
-			break;
-			
-		case 0xC6:	// DEC zp
-			operandAddress = eazp();
-			operand = zeroPageRead(operandAddress);
-			NZFlags = operand + 0xff;
-			zeroPageWrite(operandAddress, NZFlags);
-			clock += 5;
-			break;
-			
-		case 0xD6:	// DEC zp,X
-			operandAddress = eazpx();
-			operand = zeroPageRead(operandAddress);
-			NZFlags = operand + 0xff;
-			zeroPageWrite(operandAddress, NZFlags);
-			clock += 6;
-			break;
-			
-		case 0xDE:	// DEC abs,X
-			operandAddress = eaabsx();
-			operand = memoryRead(operandAddress);
-			NZFlags = operand + 0xff;
-			memoryWrite(operandAddress, NZFlags);
-			clock += 7;
-			break;
-			
-		case 0xCA:	// DEX
-			NZFlags = X + 0xff;
-			X = NZFlags & 0xff;
-			clock += 2;
-			break;
-			
-		case 0x88:	// DEY
-			NZFlags = Y + 0xff;
-			Y = NZFlags & 0xff;
-			clock += 2;
-			break;
-			
-		case 0x49:	// EOR #imm
-			A ^= eaimm();
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x4D:	// EOR abs
-			A ^= memoryRead(eaabs());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x45:	// EOR zp
-			A ^= zeroPageRead(eazp());
-			NZFlags = A;
-			clock += 3;
-			break;
-			
-		case 0x41:	// EOR (zp,X)
-			A ^= memoryRead(eazpxind());
-			NZFlags = A;
-			clock += 6;
-			break;
-			
-		case 0x51:	// EOR (zp),Y
-			A ^= memoryRead(eazpindy());
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x55:	// EOR zp,X
-			A ^= zeroPageRead(eazpx());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x5D:	// EOR abs,X
-			A ^= memoryRead(eaabsx());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x59:	// EOR abs,Y
-			A ^= memoryRead(eaabsy());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0xEE:	// INC abs
-			operandAddress = eaabs();
-			operand = memoryRead(operandAddress);
-			NZFlags = operand + 1;
-			memoryWrite(operandAddress, NZFlags);
-			clock += 6;
-			break;
-			
-		case 0xE6:	// INC zp
-			operandAddress = eazp();
-			operand = zeroPageRead(operandAddress);
-			NZFlags = operand + 1;
-			zeroPageWrite(operandAddress, NZFlags);
-			clock += 5;
-			break;
-			
-		case 0xF6:	// INC zp,X
-			operandAddress = eazpx();
-			operand = zeroPageRead(operandAddress);
-			NZFlags = operand + 1;
-			zeroPageWrite(operandAddress, NZFlags);
-			clock += 6;
-			break;
-			
-		case 0xFE:	// INC abs,X
-			operandAddress = eaabsxNC();
-			operand = memoryRead(operandAddress);
-			NZFlags = operand + 1;
-			memoryWrite(operandAddress, NZFlags);
-			clock += 7;
-			break;
-			
-		case 0xE8:	// INX
-			NZFlags = X + 1;
-			X = NZFlags & 0xff;
-			clock += 2;
-			break;
-			
-		case 0xC8:	// INY
-			NZFlags = Y + 1;
-			Y = NZFlags & 0xff;
-			clock += 2;
-			break;
-			
-		case 0x4C:	// JMP abs
-			PC = eaabs();
-			clock += 3;
-			break;
-			
-		case 0x6C:	// JMP (abs)
-			PC = eaabsind();
-			clock += 5;
-			break;
-			
-		case 0x20:	// JSR abs
-			operandAddress = eaabs();
-			PC--;
-			push(PC >> 8);
-			push(PC);
-			PC = operandAddress;
-			clock += 6;
-			break;
-			
-		case 0xA9:	// LDA #imm
-			A = eaimm();
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0xAD:	// LDA abs
-			A = memoryRead(eaabs());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0xA5:	// LDA zp
-			A = zeroPageRead(eazp());
-			NZFlags = A;
-			clock += 3;
-			break;
-			
-		case 0xA1:	// LDA (zp,X)
-			A = memoryRead(eazpxind());
-			NZFlags = A;
-			clock += 6;
-			break;
-			
-		case 0xB1:	// LDA (zp),Y
-			A = memoryRead(eazpindy());
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0xB5:	// LDA zp,X
-			A = zeroPageRead(eazpx());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0xBD:	// LDA abs,X
-			A = memoryRead(eaabsx());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0xB9:	// LDA abs,Y
-			A = memoryRead(eaabsy());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0xA2:	// LDX #imm
-			X = eaimm();
-			NZFlags = X;
-			clock += 2;
-			break;
-			
-		case 0xAE:	// LDX abs
-			X = memoryRead(eaabs());
-			NZFlags = X;
-			clock += 4;
-			break;
-			
-		case 0xA6:	// LDX zp
-			X = zeroPageRead(eazp());
-			NZFlags = X;
-			clock += 3;
-			break;
-			
-		case 0xBE:	// LDX abs,Y
-			X = memoryRead(eaabsy());
-			NZFlags = X;
-			clock += 4;
-			break;
-			
-		case 0xB6:	// LDX zp,Y
-			X = zeroPageRead(eazpy());
-			NZFlags = X;
-			clock += 4;
-			break;
-			
-		case 0xA0:	// LDY #imm
-			Y = eaimm();
-			NZFlags = Y;
-			clock += 2;
-			break;
-			
-		case 0xAC:	// LDY abs
-			Y = memoryRead(eaabs());
-			NZFlags = Y;
-			clock += 4;
-			break;
-			
-		case 0xA4:	// LDY zp
-			Y = zeroPageRead(eazp());
-			NZFlags = Y;
-			clock += 3;
-			break;
-			
-		case 0xB4:	// LDY zp,X
-			Y = zeroPageRead(eazpx());
-			NZFlags = Y;
-			clock += 4;
-			break;
-			
-		case 0xBC:	// LDY abs,X
-			Y = memoryRead(eaabsx());
-			NZFlags = Y;
-			clock += 4;
-			break;
-			
-		case 0x4E:	// LSR abs
-			operandAddress = eaabs();
-			operand = memoryRead(operandAddress);
-			result = (operand & 0x01) << 8;	// just get the C bit
-			NZFlags = operand >> 1;		// result in NZFlags
-			memoryWrite(operandAddress, NZFlags);
-			clock += 6;
-			break;
-			
-		case 0x46:	// LSR zp
-			operandAddress = eazp();
-			operand = zeroPageRead(operandAddress);
-			result = (operand & 0x01) << 8;	// just get the C bit
-			NZFlags = operand >> 1;		// result in NZFlags
-			zeroPageWrite(operandAddress, NZFlags);
-			clock += 5;
-			break;
-			
-		case 0x4A:	// LSR acc
-			result = (A & 0x01) << 8;	// just get the C bit
-			A >>= 1;
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x56:	// LSR zp,X
-			operandAddress = eazpx();
-			operand = zeroPageRead(operandAddress);
-			result = (operand & 0x01) << 8;	// just get the C bit
-			NZFlags = operand >> 1;		// result in NZFlags
-			zeroPageWrite(operandAddress, NZFlags);
-			clock += 6;
-			break;
-			
-		case 0x5E:	// LSR abs,X
-			operandAddress = eaabsx();
-			operand = memoryRead(operandAddress);
-			result = (operand & 0x01) << 8;	// just get the C bit
-			NZFlags = operand >> 1;		// result in NZFlags
-			memoryWrite(operandAddress, NZFlags);
-			clock += 7;
-			break;
-			
-		case 0xEA:	// NOP
-			clock += 2;
-			break;
-			
-		case 0x09:	// ORA #imm
-			A |= eaimm();
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x0D:	// ORA abs
-			A |= memoryRead(eaabs());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x05:	// ORA zp
-			A |= zeroPageRead(eazp());
-			NZFlags = A;
-			clock += 3;
-			break;
-			
-		case 0x01:	// ORA (zp,X)
-			A |= memoryRead(eazpxind());
-			NZFlags = A;
-			clock += 6;
-			break;
-			
-		case 0x11:	// ORA (zp),Y
-			A |= memoryRead(eazpindy());
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x15:	// ORA zp,X
-			A |= zeroPageRead(eazpx());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x1D:	// ORA abs,X
-			A |= memoryRead(eaabsx());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x19:	// ORA abs,Y
-			A |= memoryRead(eaabsy());
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x48:	// PHA
-			push(A);
-			clock += 3;
-			break;
-			
-		case 0x08:	// PHP
-			setN(getFN());
-			setZ(getFZ());
-			setC(getFC());
-			push(P);
-			clock += 3;
-			break;
-			
-		case 0x68:	// PLA
-			A = pop();
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x28:	// PLP
-			P = pop() | 0x20; // fix bug in bit5 of P
-			setFC(getC());
-			setFNZ(getN(), getZ());
-			clock += 4;
-			if ((pendingIRQ > 0) && !getI()) {
-				pendingIRQ--;
-				assertIRQ();
-			}
-			break;
-			
-		case 0x2E:	// ROL abs
-			operandAddress = eaabs();
-			operand = memoryRead(operandAddress);
-			result = (operand << 1) | getFC_();
-			NZFlags = result;
-			memoryWrite(operandAddress, result);
-			clock += 6;
-			break;
-			
-		case 0x26:	// ROL zp
-			operandAddress = eazp();
-			operand = zeroPageRead(operandAddress);
-			result = (operand << 1) | getFC_();
-			NZFlags = result;
-			zeroPageWrite(operandAddress, result);
-			clock += 5;
-			break;
-			
-		case 0x2A:	// ROL acc
-			result = (A << 1) | getFC_();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x36:	// ROL zp,X
-			operandAddress = eazpx();
-			operand = zeroPageRead(operandAddress);
-			result = (operand << 1) | getFC_();
-			NZFlags = result;
-			zeroPageWrite(operandAddress, result);
-			clock += 6;
-			break;
-			
-		case 0x3E:	// ROL abs,X
-			operandAddress = eaabsx();
-			operand = memoryRead(operandAddress);
-			result = (operand << 1) | getFC_();
-			NZFlags = result;
-			memoryWrite(operandAddress, result);
-			clock += 7;
-			break;
-			
-		case 0x6E:	// ROR abs
-			operandAddress = eaabs();
-			operand = memoryRead(operandAddress);
-			result = ((operand & 0x01) << 8) | (getFC_() << 7) |
-				(operand >> 1);
-			NZFlags = result;
-			memoryWrite(operandAddress, result);
-			clock += 6;
-			break;
-			
-		case 0x66:	// ROR zp
-			operandAddress = eazp();
-			operand = zeroPageRead(operandAddress);
-			result = ((operand & 0x01) << 8) | (getFC_() << 7) |
-				(operand >> 1);
-			NZFlags = result;
-			zeroPageWrite(operandAddress, result);
-			clock += 5;
-			break;
-			
-		case 0x6A:	// ROR acc
-			result = ((A & 0x01) << 8) | (getFC_() << 7) | (A >> 1);
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x76:	// ROR zp,X
-			operandAddress = eazpx();
-			operand = zeroPageRead(operandAddress);
-			result = ((operand & 0x01) << 8) | (getFC_() << 7) |
-				(operand >> 1);
-			NZFlags = result;
-			zeroPageWrite(operandAddress, result);
-			clock += 6;
-			break;
-			
-		case 0x7E:	// ROR abs,X
-			operandAddress = eaabsx();
-			operand = memoryRead(operandAddress);
-			result = ((operand & 0x01) << 8) | (getFC_() << 7) |
-				(operand >> 1);
-			NZFlags = result;
-			memoryWrite(operandAddress, result);
-			clock += 7;
-			break;
-			
-		case 0x40:	// RTI
-			P = pop() | 0x20; // bit 5 bug of 6502
-			setFC(getC());
-			setFNZ(getN(), getZ());
-			PC = pop();	// splitting is necessary
-			PC += pop() << 8;	// because of nested macros
-			clock += 6;
-			break;
-			
-		case 0x60:	// RTS
-			PC = pop();	// splitting is necessary
-			PC += pop() << 8;	// because of nested macros
-			PC++;
-			clock += 6;
-			break;
-			
-		case 0xE9:	// SBC #imm
-			operand = 255 - eaimm();
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0xED:	// SBC abs
-			operand = 255 - memoryRead(eaabs());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0xE5:	// SBC zp
-			operand = 255 - zeroPageRead(eazp());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 3;
-			break;
-			
-		case 0xE1:	// SBC (zp,X)
-			operand = 255 - memoryRead(eazpxind());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 6;
-			break;
-			
-		case 0xF1:	// SBC (zp),Y
-			operand = 255 - memoryRead(eazpindy());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0xF5:	// SBC zp,X
-			operand = 255 - zeroPageRead(eazpx());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0xFD:	// SBC abs,X
-			operand = 255 - memoryRead(eaabsx());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0xF9:	// SBC abs,Y
-			operand = 255 - memoryRead(eaabsy());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 4;
-			break;
-			
-		case 0x38:	// SEC
-			setFC(true);
-			clock += 2;
-			break;
-			
-		case 0xF8:	// SED
-			setD(true);
-			clock += 2;
-			break;
-			
-		case 0x78:	// SEI
-			setI(true);
-			clock += 2;
-			break;
-			
-		case 0x8D:	// STA abs
-			memoryWrite(eaabs(), A);
-			clock += 4;
-			break;
-			
-		case 0x85:	// STA zp
-			zeroPageWrite(eazp(), A);
-			clock += 3;
-			break;
-			
-		case 0x81:	// STA (zp,X)
-			memoryWrite(eazpxind(), A);
-			clock += 6;
-			break;
-			
-		case 0x91:	// STA (zp),Y
-			memoryWrite(eazpindy(), A);
-			clock += 6;
-			break;
-			
-		case 0x95:	// STA zp,X
-			zeroPageWrite(eazpx(), A);
-			clock += 4;
-			break;
-			
-		case 0x9D:	// STA abs,X
-			memoryWrite(eaabsx(), A);
-			clock += 5;
-			break;
-			
-		case 0x99:	// STA abs,Y
-			memoryWrite(eaabsy(), A);
-			clock += 5;
-			break;
-			
-		case 0x8E:	// STX abs
-			memoryWrite(eaabs(), X);
-			clock += 4;
-			break;
-			
-		case 0x86:	// STX zp
-			zeroPageWrite(eazp(), X);
-			clock += 3;
-			break;
-			
-		case 0x96:	// STX zp,Y
-			zeroPageWrite(eazpy(), X);
-			clock += 4;
-			break;
-			
-		case 0x8C:	// STY abs
-			memoryWrite(eaabs(), Y);
-			clock += 4;
-			break;
-			
-		case 0x84:	// STY zp
-			zeroPageWrite(eazp(), Y);
-			clock += 3;
-			break;
-			
-		case 0x94:	// STY zp,X
-			zeroPageWrite(eazpx(), Y);
-			clock += 4;
-			break;
-			
-		case 0xAA:	// TAX
-			X = A;
-			NZFlags = X;
-			clock += 2;
-			break;
-			
-		case 0xA8:	// TAY
-			Y = A;
-			NZFlags = Y;
-			clock += 2;
-			break;
-			
-		case 0xBA:	// TSX
-			X = S;
-			NZFlags = X;
-			clock += 2;
-			break;
-			
-		case 0x8A:	// TXA
-			A = X;
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		case 0x9A:	// TXS
-			S = X;
-			clock += 2;
-			break;
-			
-		case 0x98:	// TYA
-			A = Y;
-			NZFlags = A;
-			clock += 2;
-			break;
-			
-		/*
-		 * 65C02 instructions
-		 * note: timing is not correct
-		 */	   
+    /**
+     * Macro for page crossing cycle regulation
+     */
+    private final void checkCrossPage(int addr, int offset) {
+        if ((((addr + offset) ^ addr) & 0xff00) != 0) {
+            clock++;
+        }
+    }
 
-		case 0x72:	// ADC (zp)
-			operand = memoryRead(eazpind());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			adcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x32:	// AND (zp)
-			A &= memoryRead(eazpind());
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x34:	// BIT zp,X
-			operand = zeroPageRead(eazpx());
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			clock += 3;
-			break;
-			
-		case 0x89:	// BIT #imm
-			operand = eaimm();
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			clock += 2;
-			break;
-			
-		case 0x3C:	// BIT abs,X
-			operand = eaabsx();
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			clock += 4;
-			break;
-			
-		case 0x80:	// BRA rr
-			operand = earel();
-			clock += 2;
-			branch(operand);
-			break;
-			
-		case 0xD2:	// CMP (zp)
-			result = 0x100 + A - memoryRead(eazpind());
-			NZFlags = result;
-			clock += 5;
-			break;
-			
-		case 0x3A:	// DEA acc
-			NZFlags = A + 0xff;
-			A = NZFlags & 0xff;
-			clock += 2;
-			break;
-			
-		case 0x52:	// EOR (zp)
-			A ^= memoryRead(eazpind());
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x1A:	// INA acc
-			NZFlags = A + 1;
-			A = NZFlags & 0xff;
-			clock += 2;
-			break;
-			
-		case 0x7C:	// JMP (abs,X)
-			PC = eaabsxind();
-			clock += 6;
-			break;
-			
-		case 0xB2:	// LDA (zp)
-			A = memoryRead(eazpind());
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x12:	// ORA (zp)
-			A |= memoryRead(eazpind());
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0xDA:	// PHX
-			push(X);
-			clock += 3;
-			break;
-			
-		case 0xFA:	// PLX
-			X = pop();
-			NZFlags = X;
-			clock += 4;
-			break;
-			
-		case 0x5A:	// PHY
-			push(Y);
-			clock += 3;
-			break;
-			
-		case 0x7A:	// PLY
-			Y = pop();
-			NZFlags = Y;
-			clock += 4;
-			break;
-			
-		case 0xF2:	// SBC (zp)
-			operand = 255 - memoryRead(eazpind());
-			result = operand + A + getFC_();
-			setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
-			sbcBCDAdjust();
-			A = result & 0xff;
-			NZFlags = A;
-			clock += 5;
-			break;
-			
-		case 0x92:	// STA (zp)
-			memoryWrite(eazpind(), A);
-			clock += 6;
-			break;
-			
-		case 0x9C:	// STZ abs
-			memoryWrite(eaabs(), 0);
-			clock += 4;
-			break;
-			
-		case 0x64:	// STZ zp
-			zeroPageWrite(eazp(), 0);
-			clock += 3;
-			break;
-			
-		case 0x74:	// STZ zp,X
-			zeroPageWrite(eazpx(), 0);
-			clock += 3;
-			break;
-			
-		case 0x9E:	// STZ abs,X
-			memoryWrite(eaabsx(), 0);
-			clock += 4;
-			break;
-			
-		case 0x1C:	// TRB abs
-			operandAddress = eaabs();
-			operand = memoryRead(operandAddress);
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			memoryWrite(operandAddress, (operand & ~A) & 0xff);
-			clock += 5;
-			break;
-			
-		case 0x14:	// TRB zp
-			operandAddress = eazp();
-			operand = zeroPageRead(operandAddress);
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			zeroPageWrite(operandAddress, (operand & ~A) & 0xff);
-			clock += 5;
-			break;
-			
-		case 0x0C:	// TSB abs
-			operandAddress = eaabs();
-			operand = memoryRead(operandAddress);
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			memoryWrite(operandAddress, operand | A);
-			clock += 5;
-			break;
-			
-		case 0x04:	// TSB zp
-			operandAddress = eazp();
-			operand = zeroPageRead(operandAddress);
-			setV((operand & 0x40) != 0); 
-			NZFlags = ((operand & 0x80) << 2) | (A & operand);
-			zeroPageWrite(operandAddress, operand | A);
-			clock += 5;
-			break;
+    /*
+     * Macros for effective address calculation
+     * (Macros whose names end with NC do not check for page crossing)
+     */
+    private final int eaimm() {
+        easp1 = memoryRead(PC);    PC++; return easp1;
+    }
 
-		default:	// unknown instructions
-			clock += 2;
-		}
-	}
-	
-	public final int executeInstructions(int num) {
-		// Initialize
-		int clockStart = clock;
+    private final int eazp() {
+        easp1 = memoryRead(PC); PC++; return easp1;
+    }
 
-		for (; num >= 16; num -= 16) {
-			PC &= 0xffff;			// Keep PC "sort of" bounded
-			executeInstruction(); executeInstruction();
-			executeInstruction(); executeInstruction();
-			executeInstruction(); executeInstruction();
-			executeInstruction(); executeInstruction();
-			executeInstruction(); executeInstruction();
-			executeInstruction(); executeInstruction();
-			executeInstruction(); executeInstruction();
-		}
-		PC &= 0xffff;
-		for (; num > 0; num--) {
-			executeInstruction();
-		}
+    private final int eazpx() {
+        easp1 = (memoryRead(PC) + X) & 0xff; PC++; return easp1;
+    }
 
-		return (clock - clockStart) & 0x7fffffff;
-	}
+    private final int eazpy() {
+        easp1 = (memoryRead(PC) + Y) & 0xff; PC++; return easp1;
+    }
 
-	public final void checkInterrupts() {
-		// Reset
-		if ((exceptionRegister & SIG_6502_RESET) != 0) {
-			onReset();
-			
-			A = X = Y = 0;
-			P = 0x20;
-			setFC(getC());
-			setFNZ(getN(), getZ());
-			S = 0xff;
-			PC = memoryRead(0xfffc);
-			PC |= (memoryRead(0xfffd) << 8);
-			exceptionRegister &= ~SIG_6502_RESET;
-		}
-		
-		// No NMI nor IRQ...
-		if ((exceptionRegister & SIG_6502_NMI) != 0) {
-			onNMI();
+    private final int eaabs() {
+        easp1 = memoryRead(PC);    PC++;
+        easp1 += (memoryRead(PC) << 8); PC++;
+        return easp1;
+    }
 
-			push(PC >> 8);
-			push(PC);
-			setN(getFN());
-			setZ(getFZ());
-			setC(getFC());
-			push(P);
-			PC = memoryRead(0xfffa);
-			PC |= memoryRead(0xfffb) << 8;
-			clock += 7;
-			exceptionRegister ^= SIG_6502_NMI;
-		}
-		
-		if ((exceptionRegister & SIG_6502_IRQ) != 0) {
-			onIRQ();
-		
-			if (getI()) {
-				pendingIRQ++;
-			} else {
-				push(PC >> 8);
-				push(PC);
-				setN(getFN());
-				setZ(getFZ());
-				setC(getFC());
-				setB(false);
-				push(P);
-				setI(true);
-				PC = memoryRead(0xfffe);
-				PC |= memoryRead(0xffff) << 8;
-				clock += 7;
-			}
-			exceptionRegister ^= SIG_6502_IRQ;
-		}
-	}
+    private final int earel() {
+//        easp1 = memoryRead(PC); PC++;
+//        return ((easp1 & 0x80) != 0) ? easp1 - 256 : easp1;
+        easp1 = (byte) memoryRead(PC); PC++; return easp1;
+    }
+
+    private final int eaabsx() {
+        // No cross page check...
+        // easp1 = eaabs();
+        // checkCrossPage(easp1, X);
+        // return easp1 + X;
+        return eaabs() + X;
+    }
+
+    private final int eaabsxNC() {
+        return eaabs() + X;
+    }
+
+    private final int eaabsy() {
+        // No cross page check...
+        // easp1 = eaabs();
+        // checkCrossPage(easp1, Y);
+        // return easp1 + Y;
+        return eaabs() + Y;
+    }
+
+    private final int eaabsyNC() {
+        return eaabs() + Y;
+    }
+
+    /*
+     * Indirect addressing
+     */
+    private final int eaabsind() {
+        easp1 = eaabs();
+        easp2 = memoryRead(easp1);
+        return easp2 + (memoryRead(easp1 + 1) << 8);
+    }
+
+    private final int eazpxind() {
+        easp1 = eazpx();
+        easp2 = zeroPageRead(easp1);
+        return easp2 + (zeroPageRead((easp1 + 1) & 0xff) << 8);
+    }
+
+    private final int eazpindy() {
+        easp1 = eaimm();
+        easp2 = zeroPageRead(easp1);
+        // No cross page check...
+        // easp2 += (zeroPageRead((easp1 + 1) & 0xff) << 8);
+        // checkCrossPage(easp2,Y);
+        // return easp2 + Y;
+        return easp2 + (zeroPageRead((easp1 + 1) & 0xff) << 8) + Y;
+    }
+
+    private final int eazpindyNC() {
+        easp1 = eaimm();
+        easp2 = zeroPageRead(easp1);
+        return easp2 + (zeroPageRead((easp1 + 1) & 0xff) << 8) + Y;
+    }
+
+    /*
+     * New 65C02 addressing mode
+     */
+    private final int eazpind() {
+        easp1 = eazp();
+        easp2 = zeroPageRead(easp1);
+        return easp2 + (zeroPageRead((easp1 + 1) & 0xff) << 8);
+    }
+
+    private final int eaabsxind() {
+        easp1 = eaabs();
+        easp2 = memoryRead(easp1);
+        return easp2 + (memoryRead(easp1 + 1) << 8) + X;
+    }
+
+    /*
+     * Misc. macros
+     */
+    private final void adcBCDAdjust() {
+        if (getD()) result = BCDTableAdd[result];
+    }
+
+    private final void sbcBCDAdjust() {
+        if (getD()) result = BCDTableSub[result];
+    }
+
+    private final void branch(int operand) {
+        // No cross page check...
+         // checkCrossPage(PC, operand);
+        PC += operand;
+        clock++;
+    }
+
+    /** This executes a single instruction. */
+    private final void executeInstruction() {
+        opcode = memoryRead(PC);
+        PC++;
+
+        switch(opcode) {
+        case 0x69:    // ADC #imm
+            operand = eaimm();
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x6D:    // ADC abs
+            operand = memoryRead(eaabs());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x65:    // ADC zp
+            operand = zeroPageRead(eazp());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 3;
+            break;
+
+        case 0x61:    // ADC (zp,X)
+            operand = memoryRead(eazpxind());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 6;
+            break;
+
+        case 0x71:    // ADC (zp),Y
+            operandAddress = eazpindy();
+            operand = memoryRead(operandAddress);
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x75:    // ADC zp,X
+            operandAddress = eazpx();
+            operand = zeroPageRead(operandAddress);
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x7D:    // ADC abs,X
+            operand = memoryRead(eaabsx());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x79:    // ADC abs,Y
+            operand = memoryRead(eaabsy());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x29:    // AND #imm
+            A &= eaimm();
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x2D:    // AND abs
+            A &= memoryRead(eaabs());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x25:    // AND zp
+            A &= zeroPageRead(eazp());
+            NZFlags = A;
+            clock += 3;
+            break;
+
+        case 0x21:    // AND (zp,X)
+            A &= memoryRead(eazpxind());
+            NZFlags = A;
+            clock += 6;
+            break;
+
+        case 0x31:    // AND (zp),Y
+            A &= memoryRead(eazpindy());
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x35:    // AND zp,X
+            A &= zeroPageRead(eazpx());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x3D:    // AND abs,X
+            A &= memoryRead(eaabsx());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x39:    // AND abs,Y
+            A &= memoryRead(eaabsy());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x0E:    // ASL abs
+            operandAddress = eaabs();
+            operand = memoryRead(operandAddress);
+            result = operand << 1;
+            NZFlags = result;
+            memoryWrite(operandAddress, result);
+            clock += 6;
+            break;
+
+        case 0x06:    // ASL zp
+            operandAddress = eazp();
+            operand = zeroPageRead(operandAddress);
+            result = operand << 1;
+            NZFlags = result;
+            zeroPageWrite(operandAddress, result);
+            clock += 5;
+            break;
+
+        case 0x0A:    // ASL acc
+            result = A << 1;
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x16:    // ASL zp,X
+            operandAddress = eazpx();
+            operand = zeroPageRead(operandAddress);
+            result = operand << 1;
+            NZFlags = result;
+            zeroPageWrite(operandAddress, result);
+            clock += 6;
+            break;
+
+        case 0x1E:    // ASL abs,X
+            operandAddress = eaabsx();
+            operand = memoryRead(operandAddress);
+            result = operand << 1;
+            NZFlags = result;
+            memoryWrite(operandAddress, result);
+            clock += 7;
+            break;
+
+        case 0x90:    // BCC rr
+            operand = earel();
+            clock += 2;
+            if (getFNotC())
+                branch(operand);
+            break;
+
+        case 0xB0:    // BCS rr
+            operand = earel();
+            clock += 2;
+            if (getFC())
+                branch(operand);
+            break;
+
+        case 0xF0:    // BEQ rr
+            operand = earel();
+            clock += 2;
+            if (getFZ())
+                branch(operand);
+            break;
+
+        case 0x2C:    // BIT abs
+            operand = memoryRead(eaabs());
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            clock += 4;
+            break;
+
+        case 0x24:    // BIT zp
+            operand = zeroPageRead(eazp());
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            clock += 3;
+            break;
+
+        case 0x30:    // BMI rr
+            operand = earel();
+            clock += 2;
+            if (getFN()) {
+                branch(operand);
+            }
+            break;
+
+        case 0xD0:    // BNE rr
+            operand = earel();
+            clock += 2;
+            if (getFNotZ()) {
+                branch(operand);
+            }
+            break;
+
+        case 0x10:    // BPL rr
+            operand = earel();
+            clock += 2;
+            if (getFNotN()) {
+                branch(operand);
+            }
+            break;
+
+        case 0x00:    // BRK
+            push(PC >> 8);    // save PCH, PCL & P
+            push(PC);
+            setN(getFN());
+            setZ(getFZ());
+            setC(getFC());
+            setB(true);
+            push(P);
+            setI(true);
+            PC = memoryRead(0xfffe);
+            PC |= memoryRead(0xffff) << 8;
+            clock += 7;
+            break;
+
+        case 0x50:    // BVC rr
+            operand = earel();
+            clock += 2;
+            if (!getV()) {
+                branch(operand);
+            }
+            break;
+
+        case 0x70:    // BVS rr
+            operand = earel();
+            clock += 2;
+            if (getV()) {
+                branch(operand);
+            }
+            break;
+
+        case 0x18:    // CLC rr
+            setFC(false);
+            clock += 2;
+            break;
+
+        case 0xD8:    // CLD
+            setD(false);
+            clock += 2;
+            break;
+
+        case 0x58:    // CLI
+            setI(false);
+            clock += 2;
+            if (pendingIRQ > 0) {
+                pendingIRQ--;
+                assertIRQ();
+            }
+            break;
+
+        case 0xB8:    // CLV
+            setV(false);
+            clock += 2;
+            break;
+
+        case 0xC9:    // CMP #imm
+            result = 0x100 + A - eaimm();
+            NZFlags = result;
+            clock += 2;
+            break;
+
+        case 0xCD:    // CMP abs
+            result = 0x100 + A - memoryRead(eaabs());
+            NZFlags = result;
+            clock += 4;
+            break;
+
+        case 0xC5:    // CMP zp
+            result = 0x100 + A - zeroPageRead(eazp());
+            NZFlags = result;
+            clock += 3;
+            break;
+
+        case 0xC1:    // CMP (zp,X)
+            result = 0x100 + A - memoryRead(eazpxind());
+            NZFlags = result;
+            clock += 6;
+            break;
+
+        case 0xD1:    // CMP (zp),Y
+            result = 0x100 + A - memoryRead(eazpindy());
+            NZFlags = result;
+            clock += 5;
+            break;
+
+        case 0xD5:    // CMP zp,X
+            result = 0x100 + A - zeroPageRead(eazpx());
+            NZFlags = result;
+            clock += 4;
+            break;
+
+        case 0xDD:    // CMP abs,X
+            result = 0x100 + A - memoryRead(eaabsx());
+            NZFlags = result;
+            clock += 4;
+            break;
+
+        case 0xD9:    // CMP abs,Y
+            result = 0x100 + A - memoryRead(eaabsy());
+            NZFlags = result;
+            clock += 4;
+            break;
+
+        case 0xE0:    // CPX #imm
+            result = 0x100 + X - eaimm();
+            NZFlags = result;
+            clock += 2;
+            break;
+
+        case 0xEC:    // CPX abs
+            result = 0x100 + X - memoryRead(eaabs());
+            NZFlags = result;
+            clock += 4;
+            break;
+
+        case 0xE4:    // CPX zp
+            result = 0x100 + X - zeroPageRead(eazp());
+            NZFlags = result;
+            clock += 3;
+            break;
+
+        case 0xC0:    // CPY #imm
+            result = 0x100 + Y - eaimm();
+            NZFlags = result;
+            clock += 2;
+            break;
+
+        case 0xCC:    // CPY abs
+            result = 0x100 + Y - memoryRead(eaabs());
+            NZFlags = result;
+            clock += 4;
+            break;
+
+        case 0xC4:    // CPY zp
+            result = 0x100+ Y - zeroPageRead(eazp());
+            NZFlags = result;
+            clock += 3;
+            break;
+
+        case 0xCE:    // DEC abs
+            operandAddress = eaabs();
+            operand = memoryRead(operandAddress);
+            NZFlags = operand + 0xff;
+            memoryWrite(operandAddress, NZFlags);
+            clock += 6;
+            break;
+
+        case 0xC6:    // DEC zp
+            operandAddress = eazp();
+            operand = zeroPageRead(operandAddress);
+            NZFlags = operand + 0xff;
+            zeroPageWrite(operandAddress, NZFlags);
+            clock += 5;
+            break;
+
+        case 0xD6:    // DEC zp,X
+            operandAddress = eazpx();
+            operand = zeroPageRead(operandAddress);
+            NZFlags = operand + 0xff;
+            zeroPageWrite(operandAddress, NZFlags);
+            clock += 6;
+            break;
+
+        case 0xDE:    // DEC abs,X
+            operandAddress = eaabsx();
+            operand = memoryRead(operandAddress);
+            NZFlags = operand + 0xff;
+            memoryWrite(operandAddress, NZFlags);
+            clock += 7;
+            break;
+
+        case 0xCA:    // DEX
+            NZFlags = X + 0xff;
+            X = NZFlags & 0xff;
+            clock += 2;
+            break;
+
+        case 0x88:    // DEY
+            NZFlags = Y + 0xff;
+            Y = NZFlags & 0xff;
+            clock += 2;
+            break;
+
+        case 0x49:    // EOR #imm
+            A ^= eaimm();
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x4D:    // EOR abs
+            A ^= memoryRead(eaabs());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x45:    // EOR zp
+            A ^= zeroPageRead(eazp());
+            NZFlags = A;
+            clock += 3;
+            break;
+
+        case 0x41:    // EOR (zp,X)
+            A ^= memoryRead(eazpxind());
+            NZFlags = A;
+            clock += 6;
+            break;
+
+        case 0x51:    // EOR (zp),Y
+            A ^= memoryRead(eazpindy());
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x55:    // EOR zp,X
+            A ^= zeroPageRead(eazpx());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x5D:    // EOR abs,X
+            A ^= memoryRead(eaabsx());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x59:    // EOR abs,Y
+            A ^= memoryRead(eaabsy());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0xEE:    // INC abs
+            operandAddress = eaabs();
+            operand = memoryRead(operandAddress);
+            NZFlags = operand + 1;
+            memoryWrite(operandAddress, NZFlags);
+            clock += 6;
+            break;
+
+        case 0xE6:    // INC zp
+            operandAddress = eazp();
+            operand = zeroPageRead(operandAddress);
+            NZFlags = operand + 1;
+            zeroPageWrite(operandAddress, NZFlags);
+            clock += 5;
+            break;
+
+        case 0xF6:    // INC zp,X
+            operandAddress = eazpx();
+            operand = zeroPageRead(operandAddress);
+            NZFlags = operand + 1;
+            zeroPageWrite(operandAddress, NZFlags);
+            clock += 6;
+            break;
+
+        case 0xFE:    // INC abs,X
+            operandAddress = eaabsxNC();
+            operand = memoryRead(operandAddress);
+            NZFlags = operand + 1;
+            memoryWrite(operandAddress, NZFlags);
+            clock += 7;
+            break;
+
+        case 0xE8:    // INX
+            NZFlags = X + 1;
+            X = NZFlags & 0xff;
+            clock += 2;
+            break;
+
+        case 0xC8:    // INY
+            NZFlags = Y + 1;
+            Y = NZFlags & 0xff;
+            clock += 2;
+            break;
+
+        case 0x4C:    // JMP abs
+            PC = eaabs();
+            clock += 3;
+            break;
+
+        case 0x6C:    // JMP (abs)
+            PC = eaabsind();
+            clock += 5;
+            break;
+
+        case 0x20:    // JSR abs
+            operandAddress = eaabs();
+            PC--;
+            push(PC >> 8);
+            push(PC);
+            PC = operandAddress;
+            clock += 6;
+            break;
+
+        case 0xA9:    // LDA #imm
+            A = eaimm();
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0xAD:    // LDA abs
+            A = memoryRead(eaabs());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0xA5:    // LDA zp
+            A = zeroPageRead(eazp());
+            NZFlags = A;
+            clock += 3;
+            break;
+
+        case 0xA1:    // LDA (zp,X)
+            A = memoryRead(eazpxind());
+            NZFlags = A;
+            clock += 6;
+            break;
+
+        case 0xB1:    // LDA (zp),Y
+            A = memoryRead(eazpindy());
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0xB5:    // LDA zp,X
+            A = zeroPageRead(eazpx());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0xBD:    // LDA abs,X
+            A = memoryRead(eaabsx());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0xB9:    // LDA abs,Y
+            A = memoryRead(eaabsy());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0xA2:    // LDX #imm
+            X = eaimm();
+            NZFlags = X;
+            clock += 2;
+            break;
+
+        case 0xAE:    // LDX abs
+            X = memoryRead(eaabs());
+            NZFlags = X;
+            clock += 4;
+            break;
+
+        case 0xA6:    // LDX zp
+            X = zeroPageRead(eazp());
+            NZFlags = X;
+            clock += 3;
+            break;
+
+        case 0xBE:    // LDX abs,Y
+            X = memoryRead(eaabsy());
+            NZFlags = X;
+            clock += 4;
+            break;
+
+        case 0xB6:    // LDX zp,Y
+            X = zeroPageRead(eazpy());
+            NZFlags = X;
+            clock += 4;
+            break;
+
+        case 0xA0:    // LDY #imm
+            Y = eaimm();
+            NZFlags = Y;
+            clock += 2;
+            break;
+
+        case 0xAC:    // LDY abs
+            Y = memoryRead(eaabs());
+            NZFlags = Y;
+            clock += 4;
+            break;
+
+        case 0xA4:    // LDY zp
+            Y = zeroPageRead(eazp());
+            NZFlags = Y;
+            clock += 3;
+            break;
+
+        case 0xB4:    // LDY zp,X
+            Y = zeroPageRead(eazpx());
+            NZFlags = Y;
+            clock += 4;
+            break;
+
+        case 0xBC:    // LDY abs,X
+            Y = memoryRead(eaabsx());
+            NZFlags = Y;
+            clock += 4;
+            break;
+
+        case 0x4E:    // LSR abs
+            operandAddress = eaabs();
+            operand = memoryRead(operandAddress);
+            result = (operand & 0x01) << 8;    // just get the C bit
+            NZFlags = operand >> 1;        // result in NZFlags
+            memoryWrite(operandAddress, NZFlags);
+            clock += 6;
+            break;
+
+        case 0x46:    // LSR zp
+            operandAddress = eazp();
+            operand = zeroPageRead(operandAddress);
+            result = (operand & 0x01) << 8;    // just get the C bit
+            NZFlags = operand >> 1;        // result in NZFlags
+            zeroPageWrite(operandAddress, NZFlags);
+            clock += 5;
+            break;
+
+        case 0x4A:    // LSR acc
+            result = (A & 0x01) << 8;    // just get the C bit
+            A >>= 1;
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x56:    // LSR zp,X
+            operandAddress = eazpx();
+            operand = zeroPageRead(operandAddress);
+            result = (operand & 0x01) << 8;    // just get the C bit
+            NZFlags = operand >> 1;        // result in NZFlags
+            zeroPageWrite(operandAddress, NZFlags);
+            clock += 6;
+            break;
+
+        case 0x5E:    // LSR abs,X
+            operandAddress = eaabsx();
+            operand = memoryRead(operandAddress);
+            result = (operand & 0x01) << 8;    // just get the C bit
+            NZFlags = operand >> 1;        // result in NZFlags
+            memoryWrite(operandAddress, NZFlags);
+            clock += 7;
+            break;
+
+        case 0xEA:    // NOP
+            clock += 2;
+            break;
+
+        case 0x09:    // ORA #imm
+            A |= eaimm();
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x0D:    // ORA abs
+            A |= memoryRead(eaabs());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x05:    // ORA zp
+            A |= zeroPageRead(eazp());
+            NZFlags = A;
+            clock += 3;
+            break;
+
+        case 0x01:    // ORA (zp,X)
+            A |= memoryRead(eazpxind());
+            NZFlags = A;
+            clock += 6;
+            break;
+
+        case 0x11:    // ORA (zp),Y
+            A |= memoryRead(eazpindy());
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x15:    // ORA zp,X
+            A |= zeroPageRead(eazpx());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x1D:    // ORA abs,X
+            A |= memoryRead(eaabsx());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x19:    // ORA abs,Y
+            A |= memoryRead(eaabsy());
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x48:    // PHA
+            push(A);
+            clock += 3;
+            break;
+
+        case 0x08:    // PHP
+            setN(getFN());
+            setZ(getFZ());
+            setC(getFC());
+            push(P);
+            clock += 3;
+            break;
+
+        case 0x68:    // PLA
+            A = pop();
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x28:    // PLP
+            P = pop() | 0x20; // fix bug in bit5 of P
+            setFC(getC());
+            setFNZ(getN(), getZ());
+            clock += 4;
+            if ((pendingIRQ > 0) && !getI()) {
+                pendingIRQ--;
+                assertIRQ();
+            }
+            break;
+
+        case 0x2E:    // ROL abs
+            operandAddress = eaabs();
+            operand = memoryRead(operandAddress);
+            result = (operand << 1) | getFC_();
+            NZFlags = result;
+            memoryWrite(operandAddress, result);
+            clock += 6;
+            break;
+
+        case 0x26:    // ROL zp
+            operandAddress = eazp();
+            operand = zeroPageRead(operandAddress);
+            result = (operand << 1) | getFC_();
+            NZFlags = result;
+            zeroPageWrite(operandAddress, result);
+            clock += 5;
+            break;
+
+        case 0x2A:    // ROL acc
+            result = (A << 1) | getFC_();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x36:    // ROL zp,X
+            operandAddress = eazpx();
+            operand = zeroPageRead(operandAddress);
+            result = (operand << 1) | getFC_();
+            NZFlags = result;
+            zeroPageWrite(operandAddress, result);
+            clock += 6;
+            break;
+
+        case 0x3E:    // ROL abs,X
+            operandAddress = eaabsx();
+            operand = memoryRead(operandAddress);
+            result = (operand << 1) | getFC_();
+            NZFlags = result;
+            memoryWrite(operandAddress, result);
+            clock += 7;
+            break;
+
+        case 0x6E:    // ROR abs
+            operandAddress = eaabs();
+            operand = memoryRead(operandAddress);
+            result = ((operand & 0x01) << 8) | (getFC_() << 7) |
+                (operand >> 1);
+            NZFlags = result;
+            memoryWrite(operandAddress, result);
+            clock += 6;
+            break;
+
+        case 0x66:    // ROR zp
+            operandAddress = eazp();
+            operand = zeroPageRead(operandAddress);
+            result = ((operand & 0x01) << 8) | (getFC_() << 7) |
+                (operand >> 1);
+            NZFlags = result;
+            zeroPageWrite(operandAddress, result);
+            clock += 5;
+            break;
+
+        case 0x6A:    // ROR acc
+            result = ((A & 0x01) << 8) | (getFC_() << 7) | (A >> 1);
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x76:    // ROR zp,X
+            operandAddress = eazpx();
+            operand = zeroPageRead(operandAddress);
+            result = ((operand & 0x01) << 8) | (getFC_() << 7) |
+                (operand >> 1);
+            NZFlags = result;
+            zeroPageWrite(operandAddress, result);
+            clock += 6;
+            break;
+
+        case 0x7E:    // ROR abs,X
+            operandAddress = eaabsx();
+            operand = memoryRead(operandAddress);
+            result = ((operand & 0x01) << 8) | (getFC_() << 7) |
+                (operand >> 1);
+            NZFlags = result;
+            memoryWrite(operandAddress, result);
+            clock += 7;
+            break;
+
+        case 0x40:    // RTI
+            P = pop() | 0x20; // bit 5 bug of 6502
+            setFC(getC());
+            setFNZ(getN(), getZ());
+            PC = pop();    // splitting is necessary
+            PC += pop() << 8;    // because of nested macros
+            clock += 6;
+            break;
+
+        case 0x60:    // RTS
+            PC = pop();    // splitting is necessary
+            PC += pop() << 8;    // because of nested macros
+            PC++;
+            clock += 6;
+            break;
+
+        case 0xE9:    // SBC #imm
+            operand = 255 - eaimm();
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0xED:    // SBC abs
+            operand = 255 - memoryRead(eaabs());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0xE5:    // SBC zp
+            operand = 255 - zeroPageRead(eazp());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 3;
+            break;
+
+        case 0xE1:    // SBC (zp,X)
+            operand = 255 - memoryRead(eazpxind());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 6;
+            break;
+
+        case 0xF1:    // SBC (zp),Y
+            operand = 255 - memoryRead(eazpindy());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0xF5:    // SBC zp,X
+            operand = 255 - zeroPageRead(eazpx());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0xFD:    // SBC abs,X
+            operand = 255 - memoryRead(eaabsx());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0xF9:    // SBC abs,Y
+            operand = 255 - memoryRead(eaabsy());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 4;
+            break;
+
+        case 0x38:    // SEC
+            setFC(true);
+            clock += 2;
+            break;
+
+        case 0xF8:    // SED
+            setD(true);
+            clock += 2;
+            break;
+
+        case 0x78:    // SEI
+            setI(true);
+            clock += 2;
+            break;
+
+        case 0x8D:    // STA abs
+            memoryWrite(eaabs(), A);
+            clock += 4;
+            break;
+
+        case 0x85:    // STA zp
+            zeroPageWrite(eazp(), A);
+            clock += 3;
+            break;
+
+        case 0x81:    // STA (zp,X)
+            memoryWrite(eazpxind(), A);
+            clock += 6;
+            break;
+
+        case 0x91:    // STA (zp),Y
+            memoryWrite(eazpindy(), A);
+            clock += 6;
+            break;
+
+        case 0x95:    // STA zp,X
+            zeroPageWrite(eazpx(), A);
+            clock += 4;
+            break;
+
+        case 0x9D:    // STA abs,X
+            memoryWrite(eaabsx(), A);
+            clock += 5;
+            break;
+
+        case 0x99:    // STA abs,Y
+            memoryWrite(eaabsy(), A);
+            clock += 5;
+            break;
+
+        case 0x8E:    // STX abs
+            memoryWrite(eaabs(), X);
+            clock += 4;
+            break;
+
+        case 0x86:    // STX zp
+            zeroPageWrite(eazp(), X);
+            clock += 3;
+            break;
+
+        case 0x96:    // STX zp,Y
+            zeroPageWrite(eazpy(), X);
+            clock += 4;
+            break;
+
+        case 0x8C:    // STY abs
+            memoryWrite(eaabs(), Y);
+            clock += 4;
+            break;
+
+        case 0x84:    // STY zp
+            zeroPageWrite(eazp(), Y);
+            clock += 3;
+            break;
+
+        case 0x94:    // STY zp,X
+            zeroPageWrite(eazpx(), Y);
+            clock += 4;
+            break;
+
+        case 0xAA:    // TAX
+            X = A;
+            NZFlags = X;
+            clock += 2;
+            break;
+
+        case 0xA8:    // TAY
+            Y = A;
+            NZFlags = Y;
+            clock += 2;
+            break;
+
+        case 0xBA:    // TSX
+            X = S;
+            NZFlags = X;
+            clock += 2;
+            break;
+
+        case 0x8A:    // TXA
+            A = X;
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        case 0x9A:    // TXS
+            S = X;
+            clock += 2;
+            break;
+
+        case 0x98:    // TYA
+            A = Y;
+            NZFlags = A;
+            clock += 2;
+            break;
+
+        /*
+         * 65C02 instructions
+         * note: timing is not correct
+         */
+
+        case 0x72:    // ADC (zp)
+            operand = memoryRead(eazpind());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            adcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x32:    // AND (zp)
+            A &= memoryRead(eazpind());
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x34:    // BIT zp,X
+            operand = zeroPageRead(eazpx());
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            clock += 3;
+            break;
+
+        case 0x89:    // BIT #imm
+            operand = eaimm();
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            clock += 2;
+            break;
+
+        case 0x3C:    // BIT abs,X
+            operand = eaabsx();
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            clock += 4;
+            break;
+
+        case 0x80:    // BRA rr
+            operand = earel();
+            clock += 2;
+            branch(operand);
+            break;
+
+        case 0xD2:    // CMP (zp)
+            result = 0x100 + A - memoryRead(eazpind());
+            NZFlags = result;
+            clock += 5;
+            break;
+
+        case 0x3A:    // DEA acc
+            NZFlags = A + 0xff;
+            A = NZFlags & 0xff;
+            clock += 2;
+            break;
+
+        case 0x52:    // EOR (zp)
+            A ^= memoryRead(eazpind());
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x1A:    // INA acc
+            NZFlags = A + 1;
+            A = NZFlags & 0xff;
+            clock += 2;
+            break;
+
+        case 0x7C:    // JMP (abs,X)
+            PC = eaabsxind();
+            clock += 6;
+            break;
+
+        case 0xB2:    // LDA (zp)
+            A = memoryRead(eazpind());
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x12:    // ORA (zp)
+            A |= memoryRead(eazpind());
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0xDA:    // PHX
+            push(X);
+            clock += 3;
+            break;
+
+        case 0xFA:    // PLX
+            X = pop();
+            NZFlags = X;
+            clock += 4;
+            break;
+
+        case 0x5A:    // PHY
+            push(Y);
+            clock += 3;
+            break;
+
+        case 0x7A:    // PLY
+            Y = pop();
+            NZFlags = Y;
+            clock += 4;
+            break;
+
+        case 0xF2:    // SBC (zp)
+            operand = 255 - memoryRead(eazpind());
+            result = operand + A + getFC_();
+            setV(!(((operand ^ A) & 0x80) != 0) && (((A ^ result) & 0x80) != 0));
+            sbcBCDAdjust();
+            A = result & 0xff;
+            NZFlags = A;
+            clock += 5;
+            break;
+
+        case 0x92:    // STA (zp)
+            memoryWrite(eazpind(), A);
+            clock += 6;
+            break;
+
+        case 0x9C:    // STZ abs
+            memoryWrite(eaabs(), 0);
+            clock += 4;
+            break;
+
+        case 0x64:    // STZ zp
+            zeroPageWrite(eazp(), 0);
+            clock += 3;
+            break;
+
+        case 0x74:    // STZ zp,X
+            zeroPageWrite(eazpx(), 0);
+            clock += 3;
+            break;
+
+        case 0x9E:    // STZ abs,X
+            memoryWrite(eaabsx(), 0);
+            clock += 4;
+            break;
+
+        case 0x1C:    // TRB abs
+            operandAddress = eaabs();
+            operand = memoryRead(operandAddress);
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            memoryWrite(operandAddress, (operand & ~A) & 0xff);
+            clock += 5;
+            break;
+
+        case 0x14:    // TRB zp
+            operandAddress = eazp();
+            operand = zeroPageRead(operandAddress);
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            zeroPageWrite(operandAddress, (operand & ~A) & 0xff);
+            clock += 5;
+            break;
+
+        case 0x0C:    // TSB abs
+            operandAddress = eaabs();
+            operand = memoryRead(operandAddress);
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            memoryWrite(operandAddress, operand | A);
+            clock += 5;
+            break;
+
+        case 0x04:    // TSB zp
+            operandAddress = eazp();
+            operand = zeroPageRead(operandAddress);
+            setV((operand & 0x40) != 0);
+            NZFlags = ((operand & 0x80) << 2) | (A & operand);
+            zeroPageWrite(operandAddress, operand | A);
+            clock += 5;
+            break;
+
+        default:    // unknown instructions
+            clock += 2;
+        }
+    }
+
+    public final int executeInstructions(int num) {
+        // Initialize
+        int clockStart = clock;
+
+        for (; num >= 16; num -= 16) {
+            PC &= 0xffff;            // Keep PC "sort of" bounded
+            executeInstruction(); executeInstruction();
+            executeInstruction(); executeInstruction();
+            executeInstruction(); executeInstruction();
+            executeInstruction(); executeInstruction();
+            executeInstruction(); executeInstruction();
+            executeInstruction(); executeInstruction();
+            executeInstruction(); executeInstruction();
+        }
+        PC &= 0xffff;
+        for (; num > 0; num--) {
+            executeInstruction();
+        }
+
+        return (clock - clockStart) & 0x7fffffff;
+    }
+
+    public final void checkInterrupts() {
+        // Reset
+        if ((exceptionRegister & SIG_6502_RESET) != 0) {
+            onReset();
+
+            A = X = Y = 0;
+            P = 0x20;
+            setFC(getC());
+            setFNZ(getN(), getZ());
+            S = 0xff;
+            PC = memoryRead(0xfffc);
+            PC |= (memoryRead(0xfffd) << 8);
+            exceptionRegister &= ~SIG_6502_RESET;
+        }
+
+        // No NMI nor IRQ...
+        if ((exceptionRegister & SIG_6502_NMI) != 0) {
+            onNMI();
+
+            push(PC >> 8);
+            push(PC);
+            setN(getFN());
+            setZ(getFZ());
+            setC(getFC());
+            push(P);
+            PC = memoryRead(0xfffa);
+            PC |= memoryRead(0xfffb) << 8;
+            clock += 7;
+            exceptionRegister ^= SIG_6502_NMI;
+        }
+
+        if ((exceptionRegister & SIG_6502_IRQ) != 0) {
+            onIRQ();
+
+            if (getI()) {
+                pendingIRQ++;
+            } else {
+                push(PC >> 8);
+                push(PC);
+                setN(getFN());
+                setZ(getFZ());
+                setC(getFC());
+                setB(false);
+                push(P);
+                setI(true);
+                PC = memoryRead(0xfffe);
+                PC |= memoryRead(0xffff) << 8;
+                clock += 7;
+            }
+            exceptionRegister ^= SIG_6502_IRQ;
+        }
+    }
 }
diff --git a/src/main/java/vavi/apps/appleii/EmAppleII.java b/src/main/java/vavi/apps/appleii/EmAppleII.java
index ecb07a5..7baad91 100644
--- a/src/main/java/vavi/apps/appleii/EmAppleII.java
+++ b/src/main/java/vavi/apps/appleii/EmAppleII.java
@@ -9,1200 +9,1200 @@ package vavi.apps.appleii;
 
 
 public class EmAppleII extends Em6502 implements Runnable {
-	/*
-	 * Apple II memory map
-	 */
-	public static final int MEM_PHYS_ZP =		0x00000;
-	public static final int MEM_PHYS_STACK =	0x00100;
-	public static final int MEM_PHYS_RAM1 =		0x00200;
-	public static final int MEM_PHYS_TEXT =		0x00400;
-	public static final int MEM_PHYS_RAM2 =		0x00800;
-	public static final int MEM_PHYS_HIRES =	0x02000;
-	public static final int MEM_PHYS_RAM3 =		0x04000;
-	public static final int MEM_PHYS_IO =		0x0c000;
-	public static final int MEM_PHYS_ROM_LOW =	0x0d000;
-	public static final int MEM_PHYS_ROM_HIGH =	0x0e000;
+    /*
+     * Apple II memory map
+     */
+    public static final int MEM_PHYS_ZP =        0x00000;
+    public static final int MEM_PHYS_STACK =    0x00100;
+    public static final int MEM_PHYS_RAM1 =        0x00200;
+    public static final int MEM_PHYS_TEXT =        0x00400;
+    public static final int MEM_PHYS_RAM2 =        0x00800;
+    public static final int MEM_PHYS_HIRES =    0x02000;
+    public static final int MEM_PHYS_RAM3 =        0x04000;
+    public static final int MEM_PHYS_IO =        0x0c000;
+    public static final int MEM_PHYS_ROM_LOW =    0x0d000;
+    public static final int MEM_PHYS_ROM_HIGH =    0x0e000;
 
-	public static final int MEM_MAIN_RAM1 =		0x00200;
-	public static final int MEM_MAIN_TEXT =		0x00400;
-	public static final int MEM_MAIN_RAM2 =		0x00800;
-	public static final int MEM_MAIN_HIRES =	0x02000;
-	public static final int MEM_MAIN_RAM3 =		0x04000;
-	public static final int MEM_MAIN_LC1 =		0x0c000;
-	public static final int MEM_MAIN_LC2 =		0x0d000;
-	public static final int MEM_MAIN_LC_HIGH =	0x0e000;
+    public static final int MEM_MAIN_RAM1 =        0x00200;
+    public static final int MEM_MAIN_TEXT =        0x00400;
+    public static final int MEM_MAIN_RAM2 =        0x00800;
+    public static final int MEM_MAIN_HIRES =    0x02000;
+    public static final int MEM_MAIN_RAM3 =        0x04000;
+    public static final int MEM_MAIN_LC1 =        0x0c000;
+    public static final int MEM_MAIN_LC2 =        0x0d000;
+    public static final int MEM_MAIN_LC_HIGH =    0x0e000;
 
-	public static final int MEM_AUX_ZP =		0x10000;
-	public static final int MEM_AUX_STACK =		0x10100;
-	public static final int MEM_AUX_RAM1 =		0x10200;
-	public static final int MEM_AUX_TEXT =		0x10400;
-	public static final int MEM_AUX_RAM2 =		0x10800;
-	public static final int MEM_AUX_HIRES =		0x12000;
-	public static final int MEM_AUX_RAM3 =		0x14000;
-	public static final int MEM_AUX_LC1 =		0x1c000;
-	public static final int MEM_AUX_LC2 =		0x1d000;
-	public static final int MEM_AUX_LC_HIGH =	0x1e000;
+    public static final int MEM_AUX_ZP =        0x10000;
+    public static final int MEM_AUX_STACK =        0x10100;
+    public static final int MEM_AUX_RAM1 =        0x10200;
+    public static final int MEM_AUX_TEXT =        0x10400;
+    public static final int MEM_AUX_RAM2 =        0x10800;
+    public static final int MEM_AUX_HIRES =        0x12000;
+    public static final int MEM_AUX_RAM3 =        0x14000;
+    public static final int MEM_AUX_LC1 =        0x1c000;
+    public static final int MEM_AUX_LC2 =        0x1d000;
+    public static final int MEM_AUX_LC_HIGH =    0x1e000;
 
-	public static final int MEM_ROM_MAIN_LOW =	0x20000;
-	public static final int MEM_ROM_MAIN_HIGH =	0x21000;
-	public static final int MEM_ROM_INTERNAL =	0x23000;
-	public static final int MEM_ROM_EXTERNAL =	0x24000;
+    public static final int MEM_ROM_MAIN_LOW =    0x20000;
+    public static final int MEM_ROM_MAIN_HIGH =    0x21000;
+    public static final int MEM_ROM_INTERNAL =    0x23000;
+    public static final int MEM_ROM_EXTERNAL =    0x24000;
 
-	public static final int MEM_MAIN_ZP =		0x25000;
-	public static final int MEM_MAIN_STACK =	0x25100;
+    public static final int MEM_MAIN_ZP =        0x25000;
+    public static final int MEM_MAIN_STACK =    0x25100;
 
-	public static final int MEM_WASTE =			0x25200;
+    public static final int MEM_WASTE =            0x25200;
 
-	public static final int MEM_END =			0x28000;
-	
-	// Peripherals
-	public Paddle paddle;
-	public Peripheral[] slots;
-	
-	// Graphics	(dirty buffer every 0x80 bytes)
-	public int graphicsMode;
-	public boolean[] graphicsDirty = new boolean[0x10000 >> 7];
-	
-	public static final int GR_TEXT		= (1 << 0);
-	public static final int GR_MIXMODE	= (1 << 1);
-	public static final int GR_PAGE2	= (1 << 2);
-	public static final int GR_HIRES	= (1 << 3);
-	public static final int GR_80STORE	= (1 << 4);
-	public static final int GR_80CHAR	= (1 << 5);
-	public static final int GR_ALTCHAR	= (1 << 6);
-	public static final int GR_DHIRES	= (1 << 7);
+    public static final int MEM_END =            0x28000;
 
-	// Sound
-	public static final int SPEAKER_FLIPS_SIZE = 4096;
-	public static final int SPEAKER_FLIPS_MASK = 4095;
-	
-	public int speakerFlips[] = new int[SPEAKER_FLIPS_SIZE];
-	public int speakerFlipsPointer = 0;
+    // Peripherals
+    public Paddle paddle;
+    public Peripheral[] slots;
 
-	// Default ROM
-	private static final int[] defaultRom = {
-		// Reset routine
+    // Graphics    (dirty buffer every 0x80 bytes)
+    public int graphicsMode;
+    public boolean[] graphicsDirty = new boolean[0x10000 >> 7];
+
+    public static final int GR_TEXT        = (1 << 0);
+    public static final int GR_MIXMODE    = (1 << 1);
+    public static final int GR_PAGE2    = (1 << 2);
+    public static final int GR_HIRES    = (1 << 3);
+    public static final int GR_80STORE    = (1 << 4);
+    public static final int GR_80CHAR    = (1 << 5);
+    public static final int GR_ALTCHAR    = (1 << 6);
+    public static final int GR_DHIRES    = (1 << 7);
+
+    // Sound
+    public static final int SPEAKER_FLIPS_SIZE = 4096;
+    public static final int SPEAKER_FLIPS_MASK = 4095;
+
+    public int speakerFlips[] = new int[SPEAKER_FLIPS_SIZE];
+    public int speakerFlipsPointer = 0;
+
+    // Default ROM
+    private static final int[] defaultRom = {
+        // Reset routine
         0xad, 0x51, 0xc0,
-		0xa9, 0xa0,
-		
-		0xa2, 0xff, 0x9d, 0xff, 0x03, 0xca, 0xd0, 0xfa,
-		0xa2, 0xff, 0x9d, 0xff, 0x04, 0xca, 0xd0, 0xfa,
-		0xa2, 0xff, 0x9d, 0xff, 0x05, 0xca, 0xd0, 0xfa,
-		0xa2, 0xff, 0x9d, 0xff, 0x06, 0xca, 0xd0, 0xfa,
-			
-		0xa2, 0x27, 0xbd, 0xb8, 0xfe, 0x9d, 0x80, 0x04, 0xca, 0x10, 0xf7,
-		0xa2, 0x27, 0xbd, 0xe0, 0xfe, 0x9d, 0x00, 0x05, 0xca, 0x10, 0xf7,
-		0xa2, 0x27, 0xbd, 0x08, 0xff, 0x9d, 0x80, 0x05, 0xca, 0x10, 0xf7,
-		0xa2, 0x27, 0xbd, 0x30, 0xff, 0x9d, 0x00, 0x06, 0xca, 0x10, 0xf7,
-		0xa2, 0x27, 0xbd, 0x58, 0xff, 0x9d, 0x80, 0x07, 0xca, 0x10, 0xf7,
-		0xa2, 0x27, 0xbd, 0x80, 0xff, 0x9d, 0x28, 0x04, 0xca, 0x10, 0xf7,
-		0xa2, 0x27, 0xbd, 0xa8, 0xff, 0x9d, 0x00, 0x07, 0xca, 0x10, 0xf7,
-		0xa2, 0x27, 0xbd, 0xd0, 0xff, 0x9d, 0x00, 0x07, 0xca, 0x10, 0xf7,
+        0xa9, 0xa0,
 
-		0x4c, 0xad, 0xfe,
-		0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea,
-		
-		// Text message
+        0xa2, 0xff, 0x9d, 0xff, 0x03, 0xca, 0xd0, 0xfa,
+        0xa2, 0xff, 0x9d, 0xff, 0x04, 0xca, 0xd0, 0xfa,
+        0xa2, 0xff, 0x9d, 0xff, 0x05, 0xca, 0xd0, 0xfa,
+        0xa2, 0xff, 0x9d, 0xff, 0x06, 0xca, 0xd0, 0xfa,
+
+        0xa2, 0x27, 0xbd, 0xb8, 0xfe, 0x9d, 0x80, 0x04, 0xca, 0x10, 0xf7,
+        0xa2, 0x27, 0xbd, 0xe0, 0xfe, 0x9d, 0x00, 0x05, 0xca, 0x10, 0xf7,
+        0xa2, 0x27, 0xbd, 0x08, 0xff, 0x9d, 0x80, 0x05, 0xca, 0x10, 0xf7,
+        0xa2, 0x27, 0xbd, 0x30, 0xff, 0x9d, 0x00, 0x06, 0xca, 0x10, 0xf7,
+        0xa2, 0x27, 0xbd, 0x58, 0xff, 0x9d, 0x80, 0x07, 0xca, 0x10, 0xf7,
+        0xa2, 0x27, 0xbd, 0x80, 0xff, 0x9d, 0x28, 0x04, 0xca, 0x10, 0xf7,
+        0xa2, 0x27, 0xbd, 0xa8, 0xff, 0x9d, 0x00, 0x07, 0xca, 0x10, 0xf7,
+        0xa2, 0x27, 0xbd, 0xd0, 0xff, 0x9d, 0x00, 0x07, 0xca, 0x10, 0xf7,
+
+        0x4c, 0xad, 0xfe,
+        0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea,
+
+        // Text message
         0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0,
+        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0,
 
-		0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0x10, 0x10, 0x0c, 0x05, 0x09, 0x09,
-		0x07, 0x0f, 0x20, 0x12, 0x05, 0x11, 0x15, 0x09, 0x12, 0x05, 0x13, 0x20, 0x01, 0x0e, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0, // APPLEIIGO REQUIRES AN
+        0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0x10, 0x10, 0x0c, 0x05, 0x09, 0x09,
+        0x07, 0x0f, 0x20, 0x12, 0x05, 0x11, 0x15, 0x09, 0x12, 0x05, 0x13, 0x20, 0x01, 0x0e, 0x20, 0x20,
+        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0, // APPLEIIGO REQUIRES AN
 
-		0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0x10, 0x10, 0x0c, 0x05, 0x20, 0x09, 0x09, 0x20,
-		0x12, 0x0f, 0x0d, 0x20, 0x09, 0x0d, 0x01, 0x07, 0x05, 0x20, 0x14, 0x0f, 0x20, 0x12, 0x15, 0x0e,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0,	// APPLE II ROM IMAGE TO RUN
+        0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0x10, 0x10, 0x0c, 0x05, 0x20, 0x09, 0x09, 0x20,
+        0x12, 0x0f, 0x0d, 0x20, 0x09, 0x0d, 0x01, 0x07, 0x05, 0x20, 0x14, 0x0f, 0x20, 0x12, 0x15, 0x0e,
+        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0,    // APPLE II ROM IMAGE TO RUN
 
-		0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0,
+        0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0,
 
-		0xa0, 0xc6, 0xcf, 0xd2, 0xa0, 0xcd, 0xcf, 0xd2, 0xc5, 0xa0, 0xc9, 0xce, 0xc6, 0xcf, 0xd2, 0xcd,
-		0xc1, 0xd4, 0xc9, 0xcf, 0xce, 0xa0, 0xd0, 0xcc, 0xc5, 0xc1, 0xd3, 0xc5, 0xa0, 0xc3, 0xcc, 0xc9,
-		0xc3, 0xcb, 0xa0, 0xcf, 0xce, 0xa0, 0xa0, 0xa0,	// FOR MORE INFORMATION PLEASE CLICK ON
+        0xa0, 0xc6, 0xcf, 0xd2, 0xa0, 0xcd, 0xcf, 0xd2, 0xc5, 0xa0, 0xc9, 0xce, 0xc6, 0xcf, 0xd2, 0xcd,
+        0xc1, 0xd4, 0xc9, 0xcf, 0xce, 0xa0, 0xd0, 0xcc, 0xc5, 0xc1, 0xd3, 0xc5, 0xa0, 0xc3, 0xcc, 0xc9,
+        0xc3, 0xcb, 0xa0, 0xcf, 0xce, 0xa0, 0xa0, 0xa0,    // FOR MORE INFORMATION PLEASE CLICK ON
 
-		0xa0, 0xd4, 0xc8, 0xc5, 0xa0, 0xc1, 0xd0, 0xd0, 0xcc, 0xc5, 0xc9, 0xc9, 0xc7, 0xcf, 0xa0, 0xcc,
-		0xcf, 0xc7, 0xcf, 0xa0, 0xc2, 0xc5, 0xcc, 0xcf, 0xd7, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-		0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,	// THE APPLEIIGO LOGO BELOW
+        0xa0, 0xd4, 0xc8, 0xc5, 0xa0, 0xc1, 0xd0, 0xd0, 0xcc, 0xc5, 0xc9, 0xc9, 0xc7, 0xcf, 0xa0, 0xcc,
+        0xcf, 0xc7, 0xcf, 0xa0, 0xc2, 0xc5, 0xcc, 0xcf, 0xd7, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,    // THE APPLEIIGO LOGO BELOW
 
-		0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-		0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-		0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
 
-		0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-		0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
-		0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
 
-		// Interrupt vectors
-        0x00, 0x00, 0x30, 0xfe, 0x30, 0xfe, 0x30, 0xfe		
-	};
+        // Interrupt vectors
+        0x00, 0x00, 0x30, 0xfe, 0x30, 0xfe, 0x30, 0xfe
+    };
 
-	// Emulator
-	private boolean isRestart;
+    // Emulator
+    private boolean isRestart;
 
-	private int cpuSpeed;
-	private int clocksPerInterval;
+    private int cpuSpeed;
+    private int clocksPerInterval;
 
-	private int refreshRate;
-	private long refreshInterval;
-	private long refreshDelayCumulative;
-	private long refreshDelayPerSecond;
-	private long refreshCycle;
-	
-	// Keyboard
-	private int keyboardLatch;
+    private int refreshRate;
+    private long refreshInterval;
+    private long refreshDelayCumulative;
+    private long refreshDelayPerSecond;
+    private long refreshCycle;
 
-	// Memory offsets
-	private int[] memoryReadOffset = new int[0x101];
-	private int[] memoryWriteOffset = new int[0x101];
+    // Keyboard
+    private int keyboardLatch;
 
-	// Language card state
-	private boolean isLcReadEnable;
-	private boolean isLcWriteEnable;
-	private boolean isLcBank2;
-	
-	// Apple IIe state
-	private boolean isRomInternal;
-	private boolean isRomC3External;
-	private boolean isAuxRead;
-	private boolean isAuxWrite;
-	private boolean isAuxZeroPage;
-	private boolean isVideoVBL;
+    // Memory offsets
+    private int[] memoryReadOffset = new int[0x101];
+    private int[] memoryWriteOffset = new int[0x101];
 
-	// Thread stuff
-	private boolean isPaused = true;
-	private Thread thread;
-	
-	// Step mode
-	private boolean isStepMode = false;
-	private boolean isNextStep = false;
-	private int stepCount;
+    // Language card state
+    private boolean isLcReadEnable;
+    private boolean isLcWriteEnable;
+    private boolean isLcBank2;
+
+    // Apple IIe state
+    private boolean isRomInternal;
+    private boolean isRomC3External;
+    private boolean isAuxRead;
+    private boolean isAuxWrite;
+    private boolean isAuxZeroPage;
+    private boolean isVideoVBL;
+
+    // Thread stuff
+    private boolean isPaused = true;
+    private Thread thread;
+
+    // Step mode
+    private boolean isStepMode = false;
+    private boolean isNextStep = false;
+    private int stepCount;
 
 AppleIIGo.View view;
-	
-	/**
- 	 * Apple II class constructor
-	 */
-	public EmAppleII(AppleIIGo.View view) {
+
+    /**
+      * Apple II class constructor
+     */
+    public EmAppleII(AppleIIGo.View view) {
 this.view = view;
-		
-		// Allocate compute memory
-		mem = new byte[MEM_END];
 
-		// Initialize CPU
-		initMemoryMap();
-		setRandomSeed();
-		setCpuSpeed(1000);
-		reset();
+        // Allocate compute memory
+        mem = new byte[MEM_END];
 
-		// Setup default ROM
-		loadDefaultRom();
-		
-		// Setup paddles
-		paddle = new Paddle(this);
+        // Initialize CPU
+        initMemoryMap();
+        setRandomSeed();
+        setCpuSpeed(1000);
+        reset();
 
-		// Setup expansion slots
-		slots = new Peripheral[8];
-		for (int slot = 1; slot < 8; slot++) {
-			setPeripheral(new Peripheral(), slot);
-		}
-	}
-	
-	/**
-	 * Set random seed (so programs start randomly)
-	 */
-	public void setRandomSeed() {
-		mem[0xcd] = (byte) System.currentTimeMillis();
-	}
-	
-	/**
-	 * Load default ROM
-	 */
+        // Setup default ROM
+        loadDefaultRom();
+
+        // Setup paddles
+        paddle = new Paddle(this);
+
+        // Setup expansion slots
+        slots = new Peripheral[8];
+        for (int slot = 1; slot < 8; slot++) {
+            setPeripheral(new Peripheral(), slot);
+        }
+    }
+
+    /**
+     * Set random seed (so programs start randomly)
+     */
+    public void setRandomSeed() {
+        mem[0xcd] = (byte) System.currentTimeMillis();
+    }
+
+    /**
+     * Load default ROM
+     */
     public void loadDefaultRom() {
-		for (int offset = 0; offset < 0x1d0; offset++) {
-			mem[(MEM_ROM_MAIN_LOW + 0x3000 - 0x1d0) + offset] = (byte) defaultRom[offset];
-		}
-	}
+        for (int offset = 0; offset < 0x1d0; offset++) {
+            mem[(MEM_ROM_MAIN_LOW + 0x3000 - 0x1d0) + offset] = (byte) defaultRom[offset];
+        }
+    }
 
-	/**
- 	 * Loads ROM
-	 */
-	private boolean isValidRom(byte[] rom, int offset) {
-		// Integer BASIC?
-		if ((rom[offset + 0x1000] & 0xff) == 0x20) {
+    /**
+      * Loads ROM
+     */
+    private boolean isValidRom(byte[] rom, int offset) {
+        // Integer BASIC?
+        if ((rom[offset + 0x1000] & 0xff) == 0x20) {
 System.err.println("ROM: Integer BASIC");
-			return true;
-		}
+            return true;
+        }
 
-		// Applesoft BASIC?
-		if ((rom[offset + 0x1000] & 0xff) == 0x4c) {
+        // Applesoft BASIC?
+        if ((rom[offset + 0x1000] & 0xff) == 0x4c) {
 System.err.println("ROM: Applesoft BASIC");
-			return true;
-		}
+            return true;
+        }
 
-		return false;
-	}
-	
-	/**
-	 * @throws IllegalStateException
-	 */
-	public void loadRom(AppleIIGo.Dao dao, String resource) {
-		byte[] rom = new byte[0x8000];
-		int offset = 0;
+        return false;
+    }
 
-		dao.openInputStream(resource);
-		dao.read(rom, 0, 0x08000);
-		dao.closeInputStream();
-		
-		if (isValidRom(rom, 0x0)) {
-			offset = 0x0;
-		} else if (isValidRom(rom, 0x1000)) {
-			offset = 0x1000;
-		} else if (isValidRom(rom, 0x2000)) {
-			offset = 0x2000;
-		} else {
-		    throw new IllegalArgumentException(resource);
-		}
-			
-		// Copy main ROM
-		System.arraycopy(rom, offset, mem, MEM_ROM_MAIN_LOW, 0x03000);
+    /**
+     * @throws IllegalStateException
+     */
+    public void loadRom(AppleIIGo.Dao dao, String resource) {
+        byte[] rom = new byte[0x8000];
+        int offset = 0;
 
-		// Copy internal ROM
-		System.arraycopy(rom, offset + 0x3000, mem, MEM_ROM_INTERNAL + 0x00000, 0x01000);
-		System.arraycopy(rom, offset + 0x3800, mem, MEM_ROM_EXTERNAL + 0x00800, 0x00800);
-	}
+        dao.openInputStream(resource);
+        dao.read(rom, 0, 0x08000);
+        dao.closeInputStream();
 
-	/**
- 	 * Set peripheral
-	 */
-	public void setPeripheral(Peripheral peripheral, int slot) {
-		slots[slot] = peripheral;
-		
-		int offset = MEM_ROM_EXTERNAL + (slot << 8);
-		for (int i = 0; i < 0x100; i++) {
-			mem[offset + i] = (byte) peripheral.memoryRead(i);
-		}
-	}
+        if (isValidRom(rom, 0x0)) {
+            offset = 0x0;
+        } else if (isValidRom(rom, 0x1000)) {
+            offset = 0x1000;
+        } else if (isValidRom(rom, 0x2000)) {
+            offset = 0x2000;
+        } else {
+            throw new IllegalArgumentException(resource);
+        }
 
-	/**
- 	 * Set pause state
-	 */
-	public void setPaused(boolean value) {
-		if (isPaused == value) {
-			return;
-		}
+        // Copy main ROM
+        System.arraycopy(rom, offset, mem, MEM_ROM_MAIN_LOW, 0x03000);
 
-		isPaused = value;
-		if (isPaused) {
-			try {
-				thread.join(1000);
-			} catch (InterruptedException e) {
-			}
-		} else {
-			thread = new Thread(this);
-			thread.start();
-		}
-	}
-	
-	/**
- 	 * Get pause state
-	 */
-	public boolean getPaused() {
-		return isPaused;
-	}
+        // Copy internal ROM
+        System.arraycopy(rom, offset + 0x3000, mem, MEM_ROM_INTERNAL + 0x00000, 0x01000);
+        System.arraycopy(rom, offset + 0x3800, mem, MEM_ROM_EXTERNAL + 0x00800, 0x00800);
+    }
 
-	/**
- 	 * Keyboard push key function
-	 */
-	public void setKeyLatch(int key) {
-		key &= 0x7f;
-		keyboardLatch = (key | 0x80);
+    /**
+      * Set peripheral
+     */
+    public void setPeripheral(Peripheral peripheral, int slot) {
+        slots[slot] = peripheral;
+
+        int offset = MEM_ROM_EXTERNAL + (slot << 8);
+        for (int i = 0; i < 0x100; i++) {
+            mem[offset + i] = (byte) peripheral.memoryRead(i);
+        }
+    }
+
+    /**
+      * Set pause state
+     */
+    public void setPaused(boolean value) {
+        if (isPaused == value) {
+            return;
+        }
+
+        isPaused = value;
+        if (isPaused) {
+            try {
+                thread.join(1000);
+            } catch (InterruptedException e) {
+            }
+        } else {
+            thread = new Thread(this);
+            thread.start();
+        }
+    }
+
+    /**
+      * Get pause state
+     */
+    public boolean getPaused() {
+        return isPaused;
+    }
+
+    /**
+      * Keyboard push key function
+     */
+    public void setKeyLatch(int key) {
+        key &= 0x7f;
+        keyboardLatch = (key | 0x80);
 System.err.println("APPLE: " + keyboardLatch + ", " + ((char) key));
-	}
+    }
 
-	/**
-	 * Restart
-	 */
-	public void restart() {
-		isRestart = true;
-		assertReset();
-	}
+    /**
+     * Restart
+     */
+    public void restart() {
+        isRestart = true;
+        assertReset();
+    }
 
-	/**
-	 * Reset
-	 */
-	public void reset() {
-		isRestart = false;
-		assertReset();
-	}
+    /**
+     * Reset
+     */
+    public void reset() {
+        isRestart = false;
+        assertReset();
+    }
 
-	/**
- 	 * Set CPU speed
-	 */
-	public void setCpuSpeed(int value) {
-		if (value < 0) {
-			return;
-		}
-			
-		cpuSpeed = value;
+    /**
+      * Set CPU speed
+     */
+    public void setCpuSpeed(int value) {
+        if (value < 0) {
+            return;
+        }
 
-		refreshRate = 20;
-		refreshInterval = (int) (1000.0 / refreshRate);
-		clocksPerInterval = (int) (cpuSpeed * refreshInterval);
-	}
+        cpuSpeed = value;
 
-	/**
- 	 * Get debug mode
-	 */
-	public int getCpuSpeed() {
-		return cpuSpeed;
-	}
+        refreshRate = 20;
+        refreshInterval = (int) (1000.0 / refreshRate);
+        clocksPerInterval = (int) (cpuSpeed * refreshInterval);
+    }
 
-	/**
- 	 * Get refresh rate
-	 */
-	public int getRefreshRate() {
-		return refreshRate;
-	}
+    /**
+      * Get debug mode
+     */
+    public int getCpuSpeed() {
+        return cpuSpeed;
+    }
 
-	/**
- 	 * Set debug mode
-	 */
-	public void setStepMode(boolean value) {
-		isNextStep = false;
-		isStepMode = value;
-	}
+    /**
+      * Get refresh rate
+     */
+    public int getRefreshRate() {
+        return refreshRate;
+    }
 
-	/**
- 	 * Get debug mode
-	 */
-	public boolean getStepMode() {
-		return isStepMode;
-	}
+    /**
+      * Set debug mode
+     */
+    public void setStepMode(boolean value) {
+        isNextStep = false;
+        isStepMode = value;
+    }
 
-	/**
- 	 * Step instruction in debug mode
-	 */
-	public void stepInstructions(int value) {
-		if (value <= 0) {
-			return;
-		}
-		
-		stepCount = value;
-		isNextStep = true;
-	}
-	
-	/**
-	 * Zero pad
-	 */
-	private String zeroPad(String value, int length) {
-		length -= value.length();
-		
-		while (length > 0) {
-			value = "0" + value;
-			length--;
-		}
-		
-		return value;
-	}
+    /**
+      * Get debug mode
+     */
+    public boolean getStepMode() {
+        return isStepMode;
+    }
 
-	/**
-	 * Print a hex value
-	 */
-	private String formatHex(int value, int length) {
-		return zeroPad(Integer.toString(value, 16), length);
-	}
+    /**
+      * Step instruction in debug mode
+     */
+    public void stepInstructions(int value) {
+        if (value <= 0) {
+            return;
+        }
 
-	/**
-	 * Print a decimal value
-	 */
-	private String formatDec(int value, int commaPos) {
-		String valueString = zeroPad(Integer.toString(value), commaPos + 1);
-		int length = valueString.length();
+        stepCount = value;
+        isNextStep = true;
+    }
 
-		return valueString.substring(0, length - commaPos) +
-			"." + valueString.substring(length - commaPos, length);
-	}
+    /**
+     * Zero pad
+     */
+    private String zeroPad(String value, int length) {
+        length -= value.length();
 
-	/**
- 	 * Step instruction in debug mode
-	 */
-	public String getStatInfo() {
-	    StringBuffer statInfo = new StringBuffer();
-		long cpuSpeedCurrent;
+        while (length > 0) {
+            value = "0" + value;
+            length--;
+        }
 
-		// Calculate effective CPU speed
-		if (isPaused || isStepMode) {
-			cpuSpeedCurrent = 0;
-		} else if (refreshDelayPerSecond > 1000) {
-			cpuSpeedCurrent = cpuSpeed * 1000 / refreshDelayPerSecond;
-		} else {
-			cpuSpeedCurrent = cpuSpeed;
-		}
+        return value;
+    }
 
-		// Return A, X, Y, S, P, PC
-		statInfo.append(" A=").append(formatHex(A, 2));
-		statInfo.append(" X=").append(formatHex(X, 2));
-		statInfo.append(" Y=").append(formatHex(Y, 2));
-		statInfo.append(" P=").append(formatHex(P, 2));
-		statInfo.append(" S=").append(formatHex(S, 2));
-		statInfo.append("\n");
-		statInfo.append(" PC=").append(formatHex(PC, 4)).append("\n");
-		statInfo.append(" [PC]=");
-		statInfo.append(" ").append(formatHex(memoryRead(PC + 0), 2));
-		statInfo.append(" ").append(formatHex(memoryRead(PC + 1), 2));
-		statInfo.append(" ").append(formatHex(memoryRead(PC + 2), 2));
-		statInfo.append(" ").append(formatHex(memoryRead(PC + 3), 2));
-		statInfo.append("\n");
-		statInfo.append(" MHZ=").append(formatDec((int) cpuSpeedCurrent, 3)).append(" [").append(refreshDelayPerSecond).append(" ms/s]\n");
+    /**
+     * Print a hex value
+     */
+    private String formatHex(int value, int length) {
+        return zeroPad(Integer.toString(value, 16), length);
+    }
 
-		return statInfo.toString();
-	}
+    /**
+     * Print a decimal value
+     */
+    private String formatDec(int value, int commaPos) {
+        String valueString = zeroPad(Integer.toString(value), commaPos + 1);
+        int length = valueString.length();
 
-	/**
-	 * Noise function
-	 *
-	 * We assume a "sort-of" floating bus
-	 * (spanning memory locations 0000-3FFF)
-	 *
-	 * Correct way: We should look up the current video mode,
-	 * and sample according to what is being shown.
-	 */
-	 public int noise() {
-		 return mem[clock & 0x3fff];
-	 }
+        return valueString.substring(0, length - commaPos) +
+            "." + valueString.substring(length - commaPos, length);
+    }
 
-	/**
-	 * Read memory function
-	 *
-	 * @param	address	Address
-	 */
-	protected int memoryRead(int address) {
-		if ((address & 0xff00) == 0xc000) {
-			return ioRead(address);
-		}
+    /**
+      * Step instruction in debug mode
+     */
+    public String getStatInfo() {
+        StringBuffer statInfo = new StringBuffer();
+        long cpuSpeedCurrent;
 
-		return mem[address + memoryReadOffset[address >> 8]] & 0xff;
-	}
-	 
-	/**
- 	 * Write memory function
-	 *
-	 * @param	adderss	Address
-	 * @param	value	value
-	 */
-	protected void memoryWrite(int address, int value) {
-		if ((address & 0xff00) == 0xc000) {
-			ioWrite(address, value);
-		} else {
-			mem[address + memoryWriteOffset[address >> 8]] = (byte) value;
-			graphicsDirty[address >> 7] = true;
-		}
-	}
+        // Calculate effective CPU speed
+        if (isPaused || isStepMode) {
+            cpuSpeedCurrent = 0;
+        } else if (refreshDelayPerSecond > 1000) {
+            cpuSpeedCurrent = cpuSpeed * 1000 / refreshDelayPerSecond;
+        } else {
+            cpuSpeedCurrent = cpuSpeed;
+        }
 
-	/**
-	 * Update memory maps
-	 */
-	private void updateMainMemoryMap() {
-		int ramReadOffset, textReadOffset, hiresReadOffset;
-		int ramWriteOffset, textWriteOffset, hiresWriteOffset;
-		boolean isPage2 = ((graphicsMode & GR_PAGE2) != 0);
-		boolean is80STORE = ((graphicsMode & GR_80STORE) != 0);
-		boolean isHires = ((graphicsMode & GR_HIRES) != 0);
+        // Return A, X, Y, S, P, PC
+        statInfo.append(" A=").append(formatHex(A, 2));
+        statInfo.append(" X=").append(formatHex(X, 2));
+        statInfo.append(" Y=").append(formatHex(Y, 2));
+        statInfo.append(" P=").append(formatHex(P, 2));
+        statInfo.append(" S=").append(formatHex(S, 2));
+        statInfo.append("\n");
+        statInfo.append(" PC=").append(formatHex(PC, 4)).append("\n");
+        statInfo.append(" [PC]=");
+        statInfo.append(" ").append(formatHex(memoryRead(PC + 0), 2));
+        statInfo.append(" ").append(formatHex(memoryRead(PC + 1), 2));
+        statInfo.append(" ").append(formatHex(memoryRead(PC + 2), 2));
+        statInfo.append(" ").append(formatHex(memoryRead(PC + 3), 2));
+        statInfo.append("\n");
+        statInfo.append(" MHZ=").append(formatDec((int) cpuSpeedCurrent, 3)).append(" [").append(refreshDelayPerSecond).append(" ms/s]\n");
 
-		textReadOffset = hiresReadOffset = ramReadOffset = isAuxRead ? 
-			(MEM_AUX_RAM1 - MEM_PHYS_RAM1) : (MEM_MAIN_RAM1 - MEM_PHYS_RAM1);
-		textWriteOffset = hiresWriteOffset = ramWriteOffset = isAuxWrite ?
-			(MEM_AUX_RAM1 - MEM_PHYS_RAM1) : (MEM_MAIN_RAM1 - MEM_PHYS_RAM1);
+        return statInfo.toString();
+    }
 
-		if (is80STORE) {
-			textWriteOffset = textReadOffset = isPage2 ? (MEM_AUX_TEXT - MEM_PHYS_TEXT) : 
-				(MEM_MAIN_TEXT - MEM_PHYS_TEXT);
+    /**
+     * Noise function
+     *
+     * We assume a "sort-of" floating bus
+     * (spanning memory locations 0000-3FFF)
+     *
+     * Correct way: We should look up the current video mode,
+     * and sample according to what is being shown.
+     */
+     public int noise() {
+         return mem[clock & 0x3fff];
+     }
 
-			if (isHires) {
-				hiresWriteOffset = hiresReadOffset = textReadOffset;
-			}
-		}
-		
-		memoryReadOffset[0x02] = memoryReadOffset[0x03] = ramReadOffset;
-		memoryWriteOffset[0x02] = memoryWriteOffset[0x03] = ramWriteOffset;
-		memoryReadOffset[0x04] = memoryReadOffset[0x05] = memoryReadOffset[0x06] = memoryReadOffset[0x07] = textReadOffset;
-		memoryWriteOffset[0x04] = memoryWriteOffset[0x05] = memoryWriteOffset[0x06] = memoryWriteOffset[0x07] = textWriteOffset;
-		for (int offset = 0x08; offset < 0x20; offset++) {
-			memoryReadOffset[offset] = ramReadOffset;
-			memoryWriteOffset[offset] = ramWriteOffset;
-		}
-		for (int offset = 0x20; offset < 0x40; offset++) {
-			memoryReadOffset[offset] = hiresReadOffset;
-			memoryWriteOffset[offset] = hiresWriteOffset;
-		}
-		for (int offset = 0x40; offset < 0xc0; offset++) {
-			memoryReadOffset[offset] = ramReadOffset;
-			memoryWriteOffset[offset] = ramWriteOffset;
-		}
-	}
+    /**
+     * Read memory function
+     *
+     * @param    address    Address
+     */
+    protected int memoryRead(int address) {
+        if ((address & 0xff00) == 0xc000) {
+            return ioRead(address);
+        }
 
-	private void updateIOMemoryMap() {
-		int romOffset;
+        return mem[address + memoryReadOffset[address >> 8]] & 0xff;
+    }
 
-		if (isRomInternal) {
-			romOffset = (MEM_ROM_INTERNAL - MEM_PHYS_IO);
-		} else {
-			romOffset = (MEM_ROM_EXTERNAL - MEM_PHYS_IO);
-		}
-	
-		for (int offset = 0xc1; offset < 0xd0; offset++) {
-			memoryReadOffset[offset] = romOffset;
-		}
+    /**
+      * Write memory function
+     *
+     * @param    adderss    Address
+     * @param    value    value
+     */
+    protected void memoryWrite(int address, int value) {
+        if ((address & 0xff00) == 0xc000) {
+            ioWrite(address, value);
+        } else {
+            mem[address + memoryWriteOffset[address >> 8]] = (byte) value;
+            graphicsDirty[address >> 7] = true;
+        }
+    }
 
-		if (isRomC3External) {
-			memoryReadOffset[0xc3] = (MEM_ROM_EXTERNAL - MEM_PHYS_IO);
-		} else {
-			memoryReadOffset[0xc3] = (MEM_ROM_INTERNAL - MEM_PHYS_IO);
-		}
-	}
+    /**
+     * Update memory maps
+     */
+    private void updateMainMemoryMap() {
+        int ramReadOffset, textReadOffset, hiresReadOffset;
+        int ramWriteOffset, textWriteOffset, hiresWriteOffset;
+        boolean isPage2 = ((graphicsMode & GR_PAGE2) != 0);
+        boolean is80STORE = ((graphicsMode & GR_80STORE) != 0);
+        boolean isHires = ((graphicsMode & GR_HIRES) != 0);
 
-	private void initIOMemoryMap() {
-		for (int offset = 0xc1; offset < 0xd0; offset++) {
-			memoryWriteOffset[offset] = (MEM_WASTE - MEM_PHYS_IO);
-		}
-	}
+        textReadOffset = hiresReadOffset = ramReadOffset = isAuxRead ?
+            (MEM_AUX_RAM1 - MEM_PHYS_RAM1) : (MEM_MAIN_RAM1 - MEM_PHYS_RAM1);
+        textWriteOffset = hiresWriteOffset = ramWriteOffset = isAuxWrite ?
+            (MEM_AUX_RAM1 - MEM_PHYS_RAM1) : (MEM_MAIN_RAM1 - MEM_PHYS_RAM1);
 
-	private void updateLCMemoryMap() {
-		int lcReadOffset, lcReadOffsetHigh;
-		int lcWriteOffset, lcWriteOffsetHigh;
-		
-		if (!isLcReadEnable) {
-			lcReadOffset = (MEM_ROM_MAIN_LOW - MEM_PHYS_ROM_LOW);
-			lcReadOffsetHigh = (MEM_ROM_MAIN_LOW - MEM_PHYS_ROM_LOW);
-		} else if (isAuxZeroPage) {
-			lcReadOffset = isLcBank2 ? (MEM_AUX_LC2 - MEM_PHYS_ROM_LOW) : (MEM_AUX_LC1 - MEM_PHYS_ROM_LOW);
-			lcReadOffsetHigh = (MEM_AUX_LC_HIGH - MEM_PHYS_ROM_HIGH);
-		} else {
-			lcReadOffset = isLcBank2 ? (MEM_MAIN_LC2 - MEM_PHYS_ROM_LOW) : (MEM_MAIN_LC1 - MEM_PHYS_ROM_LOW);
-			lcReadOffsetHigh = (MEM_MAIN_LC_HIGH - MEM_PHYS_ROM_HIGH);
-		}
+        if (is80STORE) {
+            textWriteOffset = textReadOffset = isPage2 ? (MEM_AUX_TEXT - MEM_PHYS_TEXT) :
+                (MEM_MAIN_TEXT - MEM_PHYS_TEXT);
 
-		if (!isLcWriteEnable) {
-			lcWriteOffset = (MEM_WASTE - MEM_PHYS_ROM_LOW);
-			lcWriteOffsetHigh = (MEM_WASTE - MEM_PHYS_ROM_HIGH);
-		} else if (isAuxZeroPage) {
-			lcWriteOffset = isLcBank2 ? (MEM_AUX_LC2 - MEM_PHYS_ROM_LOW) : (MEM_AUX_LC1 - MEM_PHYS_ROM_LOW);
-			lcWriteOffsetHigh = (MEM_AUX_LC_HIGH - MEM_PHYS_ROM_HIGH);
-		} else {
-			lcWriteOffset = isLcBank2 ? (MEM_MAIN_LC2 - MEM_PHYS_ROM_LOW) : (MEM_MAIN_LC1 - MEM_PHYS_ROM_LOW);
-			lcWriteOffsetHigh = (MEM_MAIN_LC_HIGH - MEM_PHYS_ROM_HIGH);
-		}
-		
-		for (int offset = 0xd0; offset < 0xe0; offset++) {
-			memoryReadOffset[offset] = lcReadOffset;
-			memoryWriteOffset[offset] = lcWriteOffset;
-		}
-		for (int offset = 0xe0; offset < 0x100; offset++) {
-			memoryReadOffset[offset] = lcReadOffsetHigh;
-			memoryWriteOffset[offset] = lcWriteOffsetHigh;
-		}
-	}
+            if (isHires) {
+                hiresWriteOffset = hiresReadOffset = textReadOffset;
+            }
+        }
 
-	void initMemoryMap() {
-		initIOMemoryMap();
+        memoryReadOffset[0x02] = memoryReadOffset[0x03] = ramReadOffset;
+        memoryWriteOffset[0x02] = memoryWriteOffset[0x03] = ramWriteOffset;
+        memoryReadOffset[0x04] = memoryReadOffset[0x05] = memoryReadOffset[0x06] = memoryReadOffset[0x07] = textReadOffset;
+        memoryWriteOffset[0x04] = memoryWriteOffset[0x05] = memoryWriteOffset[0x06] = memoryWriteOffset[0x07] = textWriteOffset;
+        for (int offset = 0x08; offset < 0x20; offset++) {
+            memoryReadOffset[offset] = ramReadOffset;
+            memoryWriteOffset[offset] = ramWriteOffset;
+        }
+        for (int offset = 0x20; offset < 0x40; offset++) {
+            memoryReadOffset[offset] = hiresReadOffset;
+            memoryWriteOffset[offset] = hiresWriteOffset;
+        }
+        for (int offset = 0x40; offset < 0xc0; offset++) {
+            memoryReadOffset[offset] = ramReadOffset;
+            memoryWriteOffset[offset] = ramWriteOffset;
+        }
+    }
 
-		updateMainMemoryMap();
-		updateIOMemoryMap();
-		updateLCMemoryMap();
-	}
-	
-	/**
- 	 * Apple I/O reads 
-	 *
-	 * @param	address	Address
-	 */
-	private int ioRead(int address) {
-		address &= 0xff;
+    private void updateIOMemoryMap() {
+        int romOffset;
 
-		if (address >= 0x90) {
-			return slots[(address & 0x70) >> 4].ioRead(address);
-		}
+        if (isRomInternal) {
+            romOffset = (MEM_ROM_INTERNAL - MEM_PHYS_IO);
+        } else {
+            romOffset = (MEM_ROM_EXTERNAL - MEM_PHYS_IO);
+        }
 
-		switch (address) {
-		case 0x00: case 0x01: case 0x02: case 0x03:
-		case 0x04: case 0x05: case 0x06: case 0x07:
-		case 0x08: case 0x09: case 0x0a: case 0x0b:
-		case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-			// Keyboard data
+        for (int offset = 0xc1; offset < 0xd0; offset++) {
+            memoryReadOffset[offset] = romOffset;
+        }
+
+        if (isRomC3External) {
+            memoryReadOffset[0xc3] = (MEM_ROM_EXTERNAL - MEM_PHYS_IO);
+        } else {
+            memoryReadOffset[0xc3] = (MEM_ROM_INTERNAL - MEM_PHYS_IO);
+        }
+    }
+
+    private void initIOMemoryMap() {
+        for (int offset = 0xc1; offset < 0xd0; offset++) {
+            memoryWriteOffset[offset] = (MEM_WASTE - MEM_PHYS_IO);
+        }
+    }
+
+    private void updateLCMemoryMap() {
+        int lcReadOffset, lcReadOffsetHigh;
+        int lcWriteOffset, lcWriteOffsetHigh;
+
+        if (!isLcReadEnable) {
+            lcReadOffset = (MEM_ROM_MAIN_LOW - MEM_PHYS_ROM_LOW);
+            lcReadOffsetHigh = (MEM_ROM_MAIN_LOW - MEM_PHYS_ROM_LOW);
+        } else if (isAuxZeroPage) {
+            lcReadOffset = isLcBank2 ? (MEM_AUX_LC2 - MEM_PHYS_ROM_LOW) : (MEM_AUX_LC1 - MEM_PHYS_ROM_LOW);
+            lcReadOffsetHigh = (MEM_AUX_LC_HIGH - MEM_PHYS_ROM_HIGH);
+        } else {
+            lcReadOffset = isLcBank2 ? (MEM_MAIN_LC2 - MEM_PHYS_ROM_LOW) : (MEM_MAIN_LC1 - MEM_PHYS_ROM_LOW);
+            lcReadOffsetHigh = (MEM_MAIN_LC_HIGH - MEM_PHYS_ROM_HIGH);
+        }
+
+        if (!isLcWriteEnable) {
+            lcWriteOffset = (MEM_WASTE - MEM_PHYS_ROM_LOW);
+            lcWriteOffsetHigh = (MEM_WASTE - MEM_PHYS_ROM_HIGH);
+        } else if (isAuxZeroPage) {
+            lcWriteOffset = isLcBank2 ? (MEM_AUX_LC2 - MEM_PHYS_ROM_LOW) : (MEM_AUX_LC1 - MEM_PHYS_ROM_LOW);
+            lcWriteOffsetHigh = (MEM_AUX_LC_HIGH - MEM_PHYS_ROM_HIGH);
+        } else {
+            lcWriteOffset = isLcBank2 ? (MEM_MAIN_LC2 - MEM_PHYS_ROM_LOW) : (MEM_MAIN_LC1 - MEM_PHYS_ROM_LOW);
+            lcWriteOffsetHigh = (MEM_MAIN_LC_HIGH - MEM_PHYS_ROM_HIGH);
+        }
+
+        for (int offset = 0xd0; offset < 0xe0; offset++) {
+            memoryReadOffset[offset] = lcReadOffset;
+            memoryWriteOffset[offset] = lcWriteOffset;
+        }
+        for (int offset = 0xe0; offset < 0x100; offset++) {
+            memoryReadOffset[offset] = lcReadOffsetHigh;
+            memoryWriteOffset[offset] = lcWriteOffsetHigh;
+        }
+    }
+
+    void initMemoryMap() {
+        initIOMemoryMap();
+
+        updateMainMemoryMap();
+        updateIOMemoryMap();
+        updateLCMemoryMap();
+    }
+
+    /**
+      * Apple I/O reads
+     *
+     * @param    address    Address
+     */
+    private int ioRead(int address) {
+        address &= 0xff;
+
+        if (address >= 0x90) {
+            return slots[(address & 0x70) >> 4].ioRead(address);
+        }
+
+        switch (address) {
+        case 0x00: case 0x01: case 0x02: case 0x03:
+        case 0x04: case 0x05: case 0x06: case 0x07:
+        case 0x08: case 0x09: case 0x0a: case 0x0b:
+        case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+            // Keyboard data
 //System.err.println("io: " + address + ": " + keyboardLatch);
-			return keyboardLatch;
+            return keyboardLatch;
 
-		case 0x10:
-			// Keyboard strobe
-			keyboardLatch &= 0x7f;
-			return keyboardLatch;
-		case 0x11:
-			// Reading from LC Bank 2?
-			return (keyboardLatch & 0x7f) | (isLcBank2 ? 0x80 : 0x00);
-		case 0x12:
-			// Reading from LC?
-			return (keyboardLatch & 0x7f) | (isLcReadEnable ? 0x80 : 0x00);
-		case 0x13:
-			// Reading aux memory?
-			return (keyboardLatch & 0x7f) | (isAuxRead ? 0x80 : 0x00);
-		case 0x14:
-			// Writing aux memory?
-			return (keyboardLatch & 0x7f) | (isAuxWrite ? 0x80 : 0x00);
-		case 0x15:
-			// Using internal slot ROM?
-			return (keyboardLatch & 0x7f) | (isRomInternal ? 0x80 : 0x00);
-		case 0x16:
-			// Using slot zero page+stack+LC?
-			return (keyboardLatch & 0x7f) | (isAuxZeroPage ? 0x80 : 0x00);
-		case 0x17:
-			// Using external slot 3 ROM?
-			return (keyboardLatch & 0x7f) | (isRomC3External ? 0x80 : 0x00);
-		case 0x18:
-			// 80STORE?
-			return (keyboardLatch & 0x7f) | (((graphicsMode & GR_80STORE) != 0) ? 0x80 : 0x00);
-		case 0x19:
-			// VBL Signal low?
-			isVideoVBL = !isVideoVBL;
-			return (keyboardLatch & 0x7f) | (isVideoVBL ? 0x80 : 0x00);
-		case 0x1a:
-			// Using text mode?
-			return (keyboardLatch & 0x7f) | (((graphicsMode & GR_TEXT) != 0) ? 0x80 : 0x00);
-		case 0x1b:
-			// Using mixed mode?
-			return (keyboardLatch & 0x7f) | (((graphicsMode & GR_MIXMODE) != 0) ? 0x80 : 0x00);
-		case 0x1c:
-			// Using page 2?
-			return (keyboardLatch & 0x7f) | (((graphicsMode & GR_PAGE2) != 0) ? 0x80 : 0x00);
-		case 0x1d:
-			// Using hires?
-			return (keyboardLatch & 0x7f) | (((graphicsMode & GR_HIRES) != 0) ? 0x80 : 0x00);
-		case 0x1e:
-			// Using alt charset?
-			return (keyboardLatch & 0x7f) | (((graphicsMode & GR_ALTCHAR) != 0) ? 0x80 : 0x00);
-		case 0x1f:
-			// Using 80-column display mode?
-			return (keyboardLatch & 0x7f) | (((graphicsMode & GR_80CHAR) != 0) ? 0x80 : 0x00);
+        case 0x10:
+            // Keyboard strobe
+            keyboardLatch &= 0x7f;
+            return keyboardLatch;
+        case 0x11:
+            // Reading from LC Bank 2?
+            return (keyboardLatch & 0x7f) | (isLcBank2 ? 0x80 : 0x00);
+        case 0x12:
+            // Reading from LC?
+            return (keyboardLatch & 0x7f) | (isLcReadEnable ? 0x80 : 0x00);
+        case 0x13:
+            // Reading aux memory?
+            return (keyboardLatch & 0x7f) | (isAuxRead ? 0x80 : 0x00);
+        case 0x14:
+            // Writing aux memory?
+            return (keyboardLatch & 0x7f) | (isAuxWrite ? 0x80 : 0x00);
+        case 0x15:
+            // Using internal slot ROM?
+            return (keyboardLatch & 0x7f) | (isRomInternal ? 0x80 : 0x00);
+        case 0x16:
+            // Using slot zero page+stack+LC?
+            return (keyboardLatch & 0x7f) | (isAuxZeroPage ? 0x80 : 0x00);
+        case 0x17:
+            // Using external slot 3 ROM?
+            return (keyboardLatch & 0x7f) | (isRomC3External ? 0x80 : 0x00);
+        case 0x18:
+            // 80STORE?
+            return (keyboardLatch & 0x7f) | (((graphicsMode & GR_80STORE) != 0) ? 0x80 : 0x00);
+        case 0x19:
+            // VBL Signal low?
+            isVideoVBL = !isVideoVBL;
+            return (keyboardLatch & 0x7f) | (isVideoVBL ? 0x80 : 0x00);
+        case 0x1a:
+            // Using text mode?
+            return (keyboardLatch & 0x7f) | (((graphicsMode & GR_TEXT) != 0) ? 0x80 : 0x00);
+        case 0x1b:
+            // Using mixed mode?
+            return (keyboardLatch & 0x7f) | (((graphicsMode & GR_MIXMODE) != 0) ? 0x80 : 0x00);
+        case 0x1c:
+            // Using page 2?
+            return (keyboardLatch & 0x7f) | (((graphicsMode & GR_PAGE2) != 0) ? 0x80 : 0x00);
+        case 0x1d:
+            // Using hires?
+            return (keyboardLatch & 0x7f) | (((graphicsMode & GR_HIRES) != 0) ? 0x80 : 0x00);
+        case 0x1e:
+            // Using alt charset?
+            return (keyboardLatch & 0x7f) | (((graphicsMode & GR_ALTCHAR) != 0) ? 0x80 : 0x00);
+        case 0x1f:
+            // Using 80-column display mode?
+            return (keyboardLatch & 0x7f) | (((graphicsMode & GR_80CHAR) != 0) ? 0x80 : 0x00);
 
-		case 0x20: case 0x21: case 0x22: case 0x23:
-		case 0x24: case 0x25: case 0x26: case 0x27:
-		case 0x28: case 0x29: case 0x2a: case 0x2b:
-		case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-			// Cassette output
-			break;
+        case 0x20: case 0x21: case 0x22: case 0x23:
+        case 0x24: case 0x25: case 0x26: case 0x27:
+        case 0x28: case 0x29: case 0x2a: case 0x2b:
+        case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+            // Cassette output
+            break;
 
-		case 0x30: case 0x31: case 0x32: case 0x33:
-		case 0x34: case 0x35: case 0x36: case 0x37:
-		case 0x38: case 0x39: case 0x3a: case 0x3b:
-		case 0x3c: case 0x3d: case 0x3e: case 0x3f:
-			// Speaker
-			speakerFlips[speakerFlipsPointer] = clock;
-			speakerFlipsPointer = (speakerFlipsPointer + 1) & SPEAKER_FLIPS_MASK;
-			break;
+        case 0x30: case 0x31: case 0x32: case 0x33:
+        case 0x34: case 0x35: case 0x36: case 0x37:
+        case 0x38: case 0x39: case 0x3a: case 0x3b:
+        case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+            // Speaker
+            speakerFlips[speakerFlipsPointer] = clock;
+            speakerFlipsPointer = (speakerFlipsPointer + 1) & SPEAKER_FLIPS_MASK;
+            break;
 
-		case 0x40: case 0x41: case 0x42: case 0x43:
-		case 0x44: case 0x45: case 0x46: case 0x47:
-		case 0x48: case 0x49: case 0x4a: case 0x4b:
-		case 0x4c: case 0x4d: case 0x4e: case 0x4f:
-			// Game strobe
-			break;
+        case 0x40: case 0x41: case 0x42: case 0x43:
+        case 0x44: case 0x45: case 0x46: case 0x47:
+        case 0x48: case 0x49: case 0x4a: case 0x4b:
+        case 0x4c: case 0x4d: case 0x4e: case 0x4f:
+            // Game strobe
+            break;
 
-		case 0x50:
-			graphicsMode &= ~GR_TEXT;
-			break;
-		case 0x51:
-			graphicsMode |= GR_TEXT;
-			break;
-		case 0x52:
-			graphicsMode &= ~GR_MIXMODE;
-			break;
-		case 0x53:
-			graphicsMode |= GR_MIXMODE;
-			break;
-		case 0x54:
-			graphicsMode &= ~GR_PAGE2;
-			updateMainMemoryMap();
-			break;
-		case 0x55:
-			graphicsMode |= GR_PAGE2;
-			updateMainMemoryMap();
-			break;
-		case 0x56:
-			graphicsMode &= ~GR_HIRES;
-			updateMainMemoryMap();
-			break;
-		case 0x57:
-			graphicsMode |= GR_HIRES;
-			updateMainMemoryMap();
-			break;
-		case 0x58: case 0x59: case 0x5a: case 0x5b:
-		case 0x5c: case 0x5d:
-			// Annunciators
-			break;
-		case 0x5e:
-			graphicsMode |= GR_DHIRES;
-			break;
-		case 0x5f:
-			graphicsMode &= ~GR_DHIRES;
-			break;
+        case 0x50:
+            graphicsMode &= ~GR_TEXT;
+            break;
+        case 0x51:
+            graphicsMode |= GR_TEXT;
+            break;
+        case 0x52:
+            graphicsMode &= ~GR_MIXMODE;
+            break;
+        case 0x53:
+            graphicsMode |= GR_MIXMODE;
+            break;
+        case 0x54:
+            graphicsMode &= ~GR_PAGE2;
+            updateMainMemoryMap();
+            break;
+        case 0x55:
+            graphicsMode |= GR_PAGE2;
+            updateMainMemoryMap();
+            break;
+        case 0x56:
+            graphicsMode &= ~GR_HIRES;
+            updateMainMemoryMap();
+            break;
+        case 0x57:
+            graphicsMode |= GR_HIRES;
+            updateMainMemoryMap();
+            break;
+        case 0x58: case 0x59: case 0x5a: case 0x5b:
+        case 0x5c: case 0x5d:
+            // Annunciators
+            break;
+        case 0x5e:
+            graphicsMode |= GR_DHIRES;
+            break;
+        case 0x5f:
+            graphicsMode &= ~GR_DHIRES;
+            break;
 
-		case 0x60:
-		case 0x68:
-			// (Also cassette input)
-			return paddle.getButtonRegister(3);
-		case 0x61: 
-		case 0x69:
-			return paddle.getButtonRegister(0);
-		case 0x62:
-		case 0x6a:
-			return paddle.getButtonRegister(1);
-		case 0x63:
-		case 0x6b:
-			return paddle.getButtonRegister(2);		
-		case 0x64:
-		case 0x6c:
-			return paddle.getPaddleRegister(0);
-		case 0x65:
-		case 0x6d:
-			return paddle.getPaddleRegister(1);
-		case 0x66:
-		case 0x6e:
-			return paddle.getPaddleRegister(2);
-		case 0x67:
-		case 0x6f:
-			return paddle.getPaddleRegister(3);
+        case 0x60:
+        case 0x68:
+            // (Also cassette input)
+            return paddle.getButtonRegister(3);
+        case 0x61:
+        case 0x69:
+            return paddle.getButtonRegister(0);
+        case 0x62:
+        case 0x6a:
+            return paddle.getButtonRegister(1);
+        case 0x63:
+        case 0x6b:
+            return paddle.getButtonRegister(2);
+        case 0x64:
+        case 0x6c:
+            return paddle.getPaddleRegister(0);
+        case 0x65:
+        case 0x6d:
+            return paddle.getPaddleRegister(1);
+        case 0x66:
+        case 0x6e:
+            return paddle.getPaddleRegister(2);
+        case 0x67:
+        case 0x6f:
+            return paddle.getPaddleRegister(3);
 
-		case 0x70: case 0x71: case 0x72: case 0x73:
-		case 0x74: case 0x75: case 0x76: case 0x77:
-		case 0x78: case 0x79: case 0x7a: case 0x7b:
-		case 0x7c: case 0x7d: case 0x7e: case 0x7f:
-			paddle.triggerRegister();
-			break;
+        case 0x70: case 0x71: case 0x72: case 0x73:
+        case 0x74: case 0x75: case 0x76: case 0x77:
+        case 0x78: case 0x79: case 0x7a: case 0x7b:
+        case 0x7c: case 0x7d: case 0x7e: case 0x7f:
+            paddle.triggerRegister();
+            break;
 
-		case 0x80:
-		case 0x84:
-			isLcBank2 = true;
-			isLcReadEnable = true;
-			isLcWriteEnable = false;
-			updateLCMemoryMap();
-			break;
-		case 0x81:
-		case 0x85:
-			isLcBank2 = true;
-			isLcReadEnable = false;
-			isLcWriteEnable = true;
-			updateLCMemoryMap();
-			break;
-		case 0x82:
-		case 0x86:
-			isLcBank2 = true;
-			isLcReadEnable = false;
-			isLcWriteEnable = false;
-			updateLCMemoryMap();
-			break;
-		case 0x83:
-		case 0x87:
-			isLcBank2 = true;
-			isLcReadEnable = true;
-			isLcWriteEnable = true;
-			updateLCMemoryMap();
-			break;
-		case 0x88:
-		case 0x8c:
-			isLcBank2 = false;
-			isLcReadEnable = true;
-			isLcWriteEnable = false;
-			updateLCMemoryMap();
-			break;
-		case 0x89:
-		case 0x8d:
-			isLcBank2 = false;
-			isLcReadEnable = false;
-			isLcWriteEnable = true;
-			updateLCMemoryMap();
-			break;
-		case 0x8a:
-		case 0x8e:
-			isLcBank2 = false;
-			isLcReadEnable = false;
-			isLcWriteEnable = false;
-			updateLCMemoryMap();
-			break;
-		case 0x8b:
-		case 0x8f:
-			isLcBank2 = false;
-			isLcReadEnable = true;
-			isLcWriteEnable = true;
-			updateLCMemoryMap();
-			break;
-		case 0x90: case 0x91: case 0x92: case 0x93:
-		case 0x94: case 0x95: case 0x96: case 0x97:
-		case 0x98: case 0x99: case 0x9a: case 0x9b:
-		case 0x9c: case 0x9d: case 0x9e: case 0x9f:
-			return slots[1].ioRead(address);
-		
-		case 0xa0: case 0xa1: case 0xa2: case 0xa3:
-		case 0xa4: case 0xa5: case 0xa6: case 0xa7:
-		case 0xa8: case 0xa9: case 0xaa: case 0xab:
-		case 0xac: case 0xad: case 0xae: case 0xaf:
-			return slots[2].ioRead(address);
-		
-		case 0xb0: case 0xb1: case 0xb2: case 0xb3:
-		case 0xb4: case 0xb5: case 0xb6: case 0xb7:
-		case 0xb8: case 0xb9: case 0xba: case 0xbb:
-		case 0xbc: case 0xbd: case 0xbe: case 0xbf:
-			return slots[3].ioRead(address);
+        case 0x80:
+        case 0x84:
+            isLcBank2 = true;
+            isLcReadEnable = true;
+            isLcWriteEnable = false;
+            updateLCMemoryMap();
+            break;
+        case 0x81:
+        case 0x85:
+            isLcBank2 = true;
+            isLcReadEnable = false;
+            isLcWriteEnable = true;
+            updateLCMemoryMap();
+            break;
+        case 0x82:
+        case 0x86:
+            isLcBank2 = true;
+            isLcReadEnable = false;
+            isLcWriteEnable = false;
+            updateLCMemoryMap();
+            break;
+        case 0x83:
+        case 0x87:
+            isLcBank2 = true;
+            isLcReadEnable = true;
+            isLcWriteEnable = true;
+            updateLCMemoryMap();
+            break;
+        case 0x88:
+        case 0x8c:
+            isLcBank2 = false;
+            isLcReadEnable = true;
+            isLcWriteEnable = false;
+            updateLCMemoryMap();
+            break;
+        case 0x89:
+        case 0x8d:
+            isLcBank2 = false;
+            isLcReadEnable = false;
+            isLcWriteEnable = true;
+            updateLCMemoryMap();
+            break;
+        case 0x8a:
+        case 0x8e:
+            isLcBank2 = false;
+            isLcReadEnable = false;
+            isLcWriteEnable = false;
+            updateLCMemoryMap();
+            break;
+        case 0x8b:
+        case 0x8f:
+            isLcBank2 = false;
+            isLcReadEnable = true;
+            isLcWriteEnable = true;
+            updateLCMemoryMap();
+            break;
+        case 0x90: case 0x91: case 0x92: case 0x93:
+        case 0x94: case 0x95: case 0x96: case 0x97:
+        case 0x98: case 0x99: case 0x9a: case 0x9b:
+        case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+            return slots[1].ioRead(address);
 
-		case 0xc0: case 0xc1: case 0xc2: case 0xc3:
-		case 0xc4: case 0xc5: case 0xc6: case 0xc7:
-		case 0xc8: case 0xc9: case 0xca: case 0xcb:
-		case 0xcc: case 0xcd: case 0xce: case 0xcf:
-			return slots[4].ioRead(address);
+        case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+        case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+        case 0xa8: case 0xa9: case 0xaa: case 0xab:
+        case 0xac: case 0xad: case 0xae: case 0xaf:
+            return slots[2].ioRead(address);
 
-		case 0xd0: case 0xd1: case 0xd2: case 0xd3:
-		case 0xd4: case 0xd5: case 0xd6: case 0xd7:
-		case 0xd8: case 0xd9: case 0xda: case 0xdb:
-		case 0xdc: case 0xdd: case 0xde: case 0xdf:
-			return slots[5].ioRead(address);
-		
-		case 0xe0: case 0xe1: case 0xe2: case 0xe3:
-		case 0xe4: case 0xe5: case 0xe6: case 0xe7:
-		case 0xe8: case 0xe9: case 0xea: case 0xeb:
-		case 0xec: case 0xed: case 0xee: case 0xef:
-			return slots[6].ioRead(address);
-		
-		case 0xf0: case 0xf1: case 0xf2: case 0xf3:
-		case 0xf4: case 0xf5: case 0xf6: case 0xf7:
-		case 0xf8: case 0xf9: case 0xfa: case 0xfb:
-		case 0xfc: case 0xfd: case 0xfe: case 0xff:
-			return slots[7].ioRead(address);
-		}
+        case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+        case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+        case 0xb8: case 0xb9: case 0xba: case 0xbb:
+        case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+            return slots[3].ioRead(address);
 
-		return noise();
-	}
+        case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+        case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+        case 0xc8: case 0xc9: case 0xca: case 0xcb:
+        case 0xcc: case 0xcd: case 0xce: case 0xcf:
+            return slots[4].ioRead(address);
 
-	/**
- 	 * Apple I/O writes
-	 *
-	 * @param	address	Address
-	 * @param	value	Value
-	 */
-	private void ioWrite(int address, int value) {
-		address &= 0xff;
+        case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+        case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+        case 0xd8: case 0xd9: case 0xda: case 0xdb:
+        case 0xdc: case 0xdd: case 0xde: case 0xdf:
+            return slots[5].ioRead(address);
 
-		if (address >= 0x90) {
-			slots[(address & 0x70) >> 4].ioWrite(address, value);
-			return;
-		}
+        case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+        case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+        case 0xe8: case 0xe9: case 0xea: case 0xeb:
+        case 0xec: case 0xed: case 0xee: case 0xef:
+            return slots[6].ioRead(address);
 
-		switch (address) {
-		case 0x00:
-			// 80STORE off
-			graphicsMode &= ~GR_80STORE;
-			updateMainMemoryMap();
-			return;
-		case 0x01:
-			// 80STORE on
-			graphicsMode |= GR_80STORE;
-			updateMainMemoryMap();
-			return;
-		case 0x02:
-			// Read aux mem off
-			isAuxRead = false;
-			updateMainMemoryMap();
-			return;
-		case 0x03:
-			// Read aux mem on
-			isAuxRead = true;
-			updateMainMemoryMap();
-			return;
-		case 0x04:
-			// Write aux mem off
-			isAuxWrite = false;
-			updateMainMemoryMap();
-			return;
-		case 0x05:
-			// Write aux mem on
-			isAuxWrite = true;
-			updateMainMemoryMap();
-			return;
-		case 0x06:
-			// Do not use internal ROM
-			isRomInternal = false;
-			updateIOMemoryMap();
-			return;
-		case 0x07:
-			// Use internal ROM
-			isRomInternal = true;
-			updateIOMemoryMap();
-			return;
-		case 0x08:
-			if (isAuxZeroPage) {
-				// Physically get main zero page
-				System.arraycopy(mem, MEM_PHYS_ZP, mem, MEM_AUX_ZP, 0x200);
-				System.arraycopy(mem, MEM_MAIN_ZP, mem, MEM_PHYS_ZP, 0x200);
-			}
-			// Aux zero page off
-			isAuxZeroPage = false;
-			updateLCMemoryMap();
-			return;
-		case 0x09:
-			if (!isAuxZeroPage) {
-				// Physically get aux zero page
-				System.arraycopy(mem, MEM_PHYS_ZP, mem, MEM_MAIN_ZP, 0x200);
-				System.arraycopy(mem, MEM_AUX_ZP, mem, MEM_PHYS_ZP, 0x200);
-			}
-			// Aux zero page on
-			isAuxZeroPage = true;
-			updateLCMemoryMap();
-			return;
-		case 0x0a:
-			// Do not use external slot 3 ROM
-			isRomC3External = false;
-			updateIOMemoryMap();
-			return;
-		case 0x0b:
-			// Use external slot 3 ROM
-			isRomC3External = true;
-			updateIOMemoryMap();
-			return;
-		case 0x0c:
-			// 80c off
-			graphicsMode &= ~GR_80CHAR;
-			return;
-		case 0x0d:
-			// 80c on
-			graphicsMode |= GR_80CHAR;
-			return;
-		case 0x0e:
-			// Alt charset off
-			graphicsMode &= ~GR_ALTCHAR;
-			return;
-		case 0x0f:
-			// Alt charset on
-			graphicsMode |= GR_ALTCHAR;
-			return;
+        case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+        case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+        case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+        case 0xfc: case 0xfd: case 0xfe: case 0xff:
+            return slots[7].ioRead(address);
+        }
 
-		case 0x10: case 0x11: case 0x12: case 0x13:
-		case 0x14: case 0x15: case 0x16: case 0x17:
-		case 0x18: case 0x19: case 0x1a: case 0x1b:
-		case 0x1c: case 0x1d: case 0x1e: case 0x1f:
-			// Keyboard strobe
-			keyboardLatch &= 0x7f;
+        return noise();
+    }
+
+    /**
+      * Apple I/O writes
+     *
+     * @param    address    Address
+     * @param    value    Value
+     */
+    private void ioWrite(int address, int value) {
+        address &= 0xff;
+
+        if (address >= 0x90) {
+            slots[(address & 0x70) >> 4].ioWrite(address, value);
+            return;
+        }
+
+        switch (address) {
+        case 0x00:
+            // 80STORE off
+            graphicsMode &= ~GR_80STORE;
+            updateMainMemoryMap();
+            return;
+        case 0x01:
+            // 80STORE on
+            graphicsMode |= GR_80STORE;
+            updateMainMemoryMap();
+            return;
+        case 0x02:
+            // Read aux mem off
+            isAuxRead = false;
+            updateMainMemoryMap();
+            return;
+        case 0x03:
+            // Read aux mem on
+            isAuxRead = true;
+            updateMainMemoryMap();
+            return;
+        case 0x04:
+            // Write aux mem off
+            isAuxWrite = false;
+            updateMainMemoryMap();
+            return;
+        case 0x05:
+            // Write aux mem on
+            isAuxWrite = true;
+            updateMainMemoryMap();
+            return;
+        case 0x06:
+            // Do not use internal ROM
+            isRomInternal = false;
+            updateIOMemoryMap();
+            return;
+        case 0x07:
+            // Use internal ROM
+            isRomInternal = true;
+            updateIOMemoryMap();
+            return;
+        case 0x08:
+            if (isAuxZeroPage) {
+                // Physically get main zero page
+                System.arraycopy(mem, MEM_PHYS_ZP, mem, MEM_AUX_ZP, 0x200);
+                System.arraycopy(mem, MEM_MAIN_ZP, mem, MEM_PHYS_ZP, 0x200);
+            }
+            // Aux zero page off
+            isAuxZeroPage = false;
+            updateLCMemoryMap();
+            return;
+        case 0x09:
+            if (!isAuxZeroPage) {
+                // Physically get aux zero page
+                System.arraycopy(mem, MEM_PHYS_ZP, mem, MEM_MAIN_ZP, 0x200);
+                System.arraycopy(mem, MEM_AUX_ZP, mem, MEM_PHYS_ZP, 0x200);
+            }
+            // Aux zero page on
+            isAuxZeroPage = true;
+            updateLCMemoryMap();
+            return;
+        case 0x0a:
+            // Do not use external slot 3 ROM
+            isRomC3External = false;
+            updateIOMemoryMap();
+            return;
+        case 0x0b:
+            // Use external slot 3 ROM
+            isRomC3External = true;
+            updateIOMemoryMap();
+            return;
+        case 0x0c:
+            // 80c off
+            graphicsMode &= ~GR_80CHAR;
+            return;
+        case 0x0d:
+            // 80c on
+            graphicsMode |= GR_80CHAR;
+            return;
+        case 0x0e:
+            // Alt charset off
+            graphicsMode &= ~GR_ALTCHAR;
+            return;
+        case 0x0f:
+            // Alt charset on
+            graphicsMode |= GR_ALTCHAR;
+            return;
+
+        case 0x10: case 0x11: case 0x12: case 0x13:
+        case 0x14: case 0x15: case 0x16: case 0x17:
+        case 0x18: case 0x19: case 0x1a: case 0x1b:
+        case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+            // Keyboard strobe
+            keyboardLatch &= 0x7f;
 //System.err.println("io: " + address + ": " + keyboardLatch);
-			return;
+            return;
 
-		case 0x20: case 0x21: case 0x22: case 0x23:
-		case 0x24: case 0x25: case 0x26: case 0x27:
-		case 0x28: case 0x29: case 0x2a: case 0x2b:
-		case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-			// Cassette output
-			return;
+        case 0x20: case 0x21: case 0x22: case 0x23:
+        case 0x24: case 0x25: case 0x26: case 0x27:
+        case 0x28: case 0x29: case 0x2a: case 0x2b:
+        case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+            // Cassette output
+            return;
 
-		case 0x30: case 0x31: case 0x32: case 0x33:
-		case 0x34: case 0x35: case 0x36: case 0x37:
-		case 0x38: case 0x39: case 0x3a: case 0x3b:
-		case 0x3c: case 0x3d: case 0x3e: case 0x3f:
-			// Speaker
-			speakerFlips[speakerFlipsPointer] = clock;
-			speakerFlipsPointer = (speakerFlipsPointer + 1) & SPEAKER_FLIPS_MASK;
-			return;
+        case 0x30: case 0x31: case 0x32: case 0x33:
+        case 0x34: case 0x35: case 0x36: case 0x37:
+        case 0x38: case 0x39: case 0x3a: case 0x3b:
+        case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+            // Speaker
+            speakerFlips[speakerFlipsPointer] = clock;
+            speakerFlipsPointer = (speakerFlipsPointer + 1) & SPEAKER_FLIPS_MASK;
+            return;
 
-		case 0x40: case 0x41: case 0x42: case 0x43:
-		case 0x44: case 0x45: case 0x46: case 0x47:
-		case 0x48: case 0x49: case 0x4a: case 0x4b:
-		case 0x4c: case 0x4d: case 0x4e: case 0x4f:
-			// Game strobe
-			return;
+        case 0x40: case 0x41: case 0x42: case 0x43:
+        case 0x44: case 0x45: case 0x46: case 0x47:
+        case 0x48: case 0x49: case 0x4a: case 0x4b:
+        case 0x4c: case 0x4d: case 0x4e: case 0x4f:
+            // Game strobe
+            return;
 
-		case 0x50:
-			graphicsMode &= ~GR_TEXT;
-			return;
-		case 0x51:
-			graphicsMode |= GR_TEXT;
-			return;
-		case 0x52:
-			graphicsMode &= ~GR_MIXMODE;
-			return;
-		case 0x53:
-			graphicsMode |= GR_MIXMODE;
-			return;
-		case 0x54:
-			graphicsMode &= ~GR_PAGE2;
-			updateMainMemoryMap();
-			return;
-		case 0x55:
-			graphicsMode |= GR_PAGE2;
-			updateMainMemoryMap();
-			return;
-		case 0x56:
-			graphicsMode &= ~GR_HIRES;
-			updateMainMemoryMap();
-			return;
-		case 0x57:
-			graphicsMode |= GR_HIRES;
-			updateMainMemoryMap();
-			return;
-		case 0x58: case 0x59: case 0x5a: case 0x5b:
-		case 0x5c: case 0x5d:
-			// Annunciators
-			return;
-		case 0x5e:
-			graphicsMode |= GR_DHIRES;
-			break;
-		case 0x5f:
-			graphicsMode &= ~GR_DHIRES;
-			break;
+        case 0x50:
+            graphicsMode &= ~GR_TEXT;
+            return;
+        case 0x51:
+            graphicsMode |= GR_TEXT;
+            return;
+        case 0x52:
+            graphicsMode &= ~GR_MIXMODE;
+            return;
+        case 0x53:
+            graphicsMode |= GR_MIXMODE;
+            return;
+        case 0x54:
+            graphicsMode &= ~GR_PAGE2;
+            updateMainMemoryMap();
+            return;
+        case 0x55:
+            graphicsMode |= GR_PAGE2;
+            updateMainMemoryMap();
+            return;
+        case 0x56:
+            graphicsMode &= ~GR_HIRES;
+            updateMainMemoryMap();
+            return;
+        case 0x57:
+            graphicsMode |= GR_HIRES;
+            updateMainMemoryMap();
+            return;
+        case 0x58: case 0x59: case 0x5a: case 0x5b:
+        case 0x5c: case 0x5d:
+            // Annunciators
+            return;
+        case 0x5e:
+            graphicsMode |= GR_DHIRES;
+            break;
+        case 0x5f:
+            graphicsMode &= ~GR_DHIRES;
+            break;
 
-		case 0x60: case 0x61: case 0x62: case 0x63:
-		case 0x64: case 0x65: case 0x66: case 0x67:
-		case 0x68: case 0x69: case 0x6a: case 0x6b:
-		case 0x6c: case 0x6d: case 0x6e: case 0x6f:
-			// Cassette input/paddle data
-			return;
+        case 0x60: case 0x61: case 0x62: case 0x63:
+        case 0x64: case 0x65: case 0x66: case 0x67:
+        case 0x68: case 0x69: case 0x6a: case 0x6b:
+        case 0x6c: case 0x6d: case 0x6e: case 0x6f:
+            // Cassette input/paddle data
+            return;
 
-		case 0x70: case 0x71: case 0x72: case 0x73:
-		case 0x74: case 0x75: case 0x76: case 0x77:
-		case 0x78: case 0x79: case 0x7a: case 0x7b:
-		case 0x7c: case 0x7d: case 0x7e: case 0x7f:
-			paddle.triggerRegister();
-			return;
+        case 0x70: case 0x71: case 0x72: case 0x73:
+        case 0x74: case 0x75: case 0x76: case 0x77:
+        case 0x78: case 0x79: case 0x7a: case 0x7b:
+        case 0x7c: case 0x7d: case 0x7e: case 0x7f:
+            paddle.triggerRegister();
+            return;
 
-		case 0x80:
-		case 0x84:
-			isLcBank2 = true;
-			isLcReadEnable = true;
-			isLcWriteEnable = false;
-			updateLCMemoryMap();
-			break;
-		case 0x81:
-		case 0x85:
-			isLcBank2 = true;
-			isLcReadEnable = false;
-			isLcWriteEnable = true;
-			updateLCMemoryMap();
-			break;
-		case 0x82:
-		case 0x86:
-			isLcBank2 = true;
-			isLcReadEnable = false;
-			isLcWriteEnable = false;
-			updateLCMemoryMap();
-			break;
-		case 0x83:
-		case 0x87:
-			isLcBank2 = true;
-			isLcReadEnable = true;
-			isLcWriteEnable = true;
-			updateLCMemoryMap();
-			break;
-		case 0x88:
-		case 0x8c:
-			isLcBank2 = false;
-			isLcReadEnable = true;
-			isLcWriteEnable = false;
-			updateLCMemoryMap();
-			break;
-		case 0x89:
-		case 0x8d:
-			isLcBank2 = false;
-			isLcReadEnable = false;
-			isLcWriteEnable = true;
-			updateLCMemoryMap();
-			break;
-		case 0x8a:
-		case 0x8e:
-			isLcBank2 = false;
-			isLcReadEnable = false;
-			isLcWriteEnable = false;
-			updateLCMemoryMap();
-			break;
-		case 0x8b:
-		case 0x8f:
-			isLcBank2 = false;
-			isLcReadEnable = true;
-			isLcWriteEnable = true;
-			updateLCMemoryMap();
-			break;
-		}
-	}
+        case 0x80:
+        case 0x84:
+            isLcBank2 = true;
+            isLcReadEnable = true;
+            isLcWriteEnable = false;
+            updateLCMemoryMap();
+            break;
+        case 0x81:
+        case 0x85:
+            isLcBank2 = true;
+            isLcReadEnable = false;
+            isLcWriteEnable = true;
+            updateLCMemoryMap();
+            break;
+        case 0x82:
+        case 0x86:
+            isLcBank2 = true;
+            isLcReadEnable = false;
+            isLcWriteEnable = false;
+            updateLCMemoryMap();
+            break;
+        case 0x83:
+        case 0x87:
+            isLcBank2 = true;
+            isLcReadEnable = true;
+            isLcWriteEnable = true;
+            updateLCMemoryMap();
+            break;
+        case 0x88:
+        case 0x8c:
+            isLcBank2 = false;
+            isLcReadEnable = true;
+            isLcWriteEnable = false;
+            updateLCMemoryMap();
+            break;
+        case 0x89:
+        case 0x8d:
+            isLcBank2 = false;
+            isLcReadEnable = false;
+            isLcWriteEnable = true;
+            updateLCMemoryMap();
+            break;
+        case 0x8a:
+        case 0x8e:
+            isLcBank2 = false;
+            isLcReadEnable = false;
+            isLcWriteEnable = false;
+            updateLCMemoryMap();
+            break;
+        case 0x8b:
+        case 0x8f:
+            isLcBank2 = false;
+            isLcReadEnable = true;
+            isLcWriteEnable = true;
+            updateLCMemoryMap();
+            break;
+        }
+    }
 
-	/**
- 	 * Emulator thread
-	 */
-	public void run() {
-		try {
-			while (!isPaused) {
-				long refreshStart = System.currentTimeMillis();
-				long refreshDelay;
-				
-				checkInterrupts();
+    /**
+      * Emulator thread
+     */
+    public void run() {
+        try {
+            while (!isPaused) {
+                long refreshStart = System.currentTimeMillis();
+                long refreshDelay;
 
-				if (isStepMode) {
-					if (isNextStep) {
-						isNextStep = false;
-						executeInstructions(stepCount);
-					}
-				} else {
-					int clocksNeeded = clocksPerInterval;
-					while (clocksNeeded > 0) {
-						clocksNeeded -= executeInstructions(1 + (clocksNeeded >> 3));
-					}
-				}
+                checkInterrupts();
 
-				refreshDelay = System.currentTimeMillis() - refreshStart;
+                if (isStepMode) {
+                    if (isNextStep) {
+                        isNextStep = false;
+                        executeInstructions(stepCount);
+                    }
+                } else {
+                    int clocksNeeded = clocksPerInterval;
+                    while (clocksNeeded > 0) {
+                        clocksNeeded -= executeInstructions(1 + (clocksNeeded >> 3));
+                    }
+                }
 
-				refreshDelayCumulative += refreshDelay;
-				refreshCycle++;
-				if (refreshCycle >= refreshRate) {
-					refreshDelayPerSecond = refreshDelayCumulative;
-					refreshDelayCumulative = refreshCycle = 0;
-				}
+                refreshDelay = System.currentTimeMillis() - refreshStart;
 
-				if (refreshDelay < refreshInterval) {
-					Thread.sleep(refreshInterval - refreshDelay);
-				}
-			}
-		} catch (Throwable e) {
+                refreshDelayCumulative += refreshDelay;
+                refreshCycle++;
+                if (refreshCycle >= refreshRate) {
+                    refreshDelayPerSecond = refreshDelayCumulative;
+                    refreshDelayCumulative = refreshCycle = 0;
+                }
+
+                if (refreshDelay < refreshInterval) {
+                    Thread.sleep(refreshInterval - refreshDelay);
+                }
+            }
+        } catch (Throwable e) {
 view.debug(e);
 view.repaint();
-	    }
-	}
+        }
+    }
 
-	/**
-	 * Reset assertion code
-	 */
-	protected void onReset() {
-		// Reset IOU + MMU
-		ioWrite(0x00, 0);
-		ioWrite(0x02, 0);
-		ioWrite(0x04, 0);
-		ioWrite(0x06, 0);
-		ioWrite(0x08, 0);
-		ioWrite(0x0a, 0);
-		ioWrite(0x0c, 0);
-		ioWrite(0x0e, 0);
-		ioWrite(0x50, 0);
-		ioWrite(0x52, 0);
-		ioWrite(0x54, 0);
-		ioWrite(0x56, 0);
-		ioWrite(0x5F, 0);
-		ioWrite(0x82, 0);
+    /**
+     * Reset assertion code
+     */
+    protected void onReset() {
+        // Reset IOU + MMU
+        ioWrite(0x00, 0);
+        ioWrite(0x02, 0);
+        ioWrite(0x04, 0);
+        ioWrite(0x06, 0);
+        ioWrite(0x08, 0);
+        ioWrite(0x0a, 0);
+        ioWrite(0x0c, 0);
+        ioWrite(0x0e, 0);
+        ioWrite(0x50, 0);
+        ioWrite(0x52, 0);
+        ioWrite(0x54, 0);
+        ioWrite(0x56, 0);
+        ioWrite(0x5F, 0);
+        ioWrite(0x82, 0);
 
-		if (isRestart) {
-			// Clear RAM
-			for (int i = 0; i < MEM_ROM_MAIN_LOW; i++) {
-				mem[i] = 0;
-			}
+        if (isRestart) {
+            // Clear RAM
+            for (int i = 0; i < MEM_ROM_MAIN_LOW; i++) {
+                mem[i] = 0;
+            }
 
-			setRandomSeed();
-		}
+            setRandomSeed();
+        }
 
-		// Reset devices
-		for (int slot = 1; slot < 8; slot++) {
-			slots[slot].reset();
-		}
-	}
+        // Reset devices
+        for (int slot = 1; slot < 8; slot++) {
+            slots[slot].reset();
+        }
+    }
 }
diff --git a/src/main/java/vavi/apps/appleii/Paddle.java b/src/main/java/vavi/apps/appleii/Paddle.java
index 705452f..47cbae5 100644
--- a/src/main/java/vavi/apps/appleii/Paddle.java
+++ b/src/main/java/vavi/apps/appleii/Paddle.java
@@ -9,94 +9,94 @@ package vavi.apps.appleii;
 
 
 public class Paddle {
-	// Public variables
-	public static final int PADDLE_LOW = 0;
-	public static final int PADDLE_CENTER = 127;
-	public static final int PADDLE_HIGH = 255;
+    // Public variables
+    public static final int PADDLE_LOW = 0;
+    public static final int PADDLE_CENTER = 127;
+    public static final int PADDLE_HIGH = 255;
 
-	public static final int PADDLEMODE_DIRECT = 0;
-	public static final int PADDLEMODE_FILTERED = 1;
-	
-	// Instances of other classes
-	private EmAppleII apple;
+    public static final int PADDLEMODE_DIRECT = 0;
+    public static final int PADDLEMODE_FILTERED = 1;
 
-	// Button variables
-	private int[] buttonRegister = new int[4];
+    // Instances of other classes
+    private EmAppleII apple;
 
-	// Paddle variables
-//	private int paddleMode;
+    // Button variables
+    private int[] buttonRegister = new int[4];
 
-	private int[] paddleClockEvent = new int[4];
-	private int[] paddleClockInc = new int[4];
+    // Paddle variables
+//    private int paddleMode;
 
-	/**
-	 * Paddle class constructor
-	 *
-	 * @param	apple	The EmAppleII instance
-	 */
-	public Paddle(EmAppleII apple) {
-		this.apple = apple;
+    private int[] paddleClockEvent = new int[4];
+    private int[] paddleClockInc = new int[4];
 
-		setPaddlePos(0, PADDLE_CENTER);
-		setPaddlePos(1, PADDLE_CENTER);
-		setPaddlePos(2, PADDLE_CENTER);
-		setPaddlePos(3, PADDLE_CENTER);
-	}
-	
-	/**
-	 * Set button state
-	 *
-	 * @param	button	Paddle button
-	 * @param	state	State
-	 */
-	public void setButton(int button, boolean pressed) {
-		buttonRegister[button] = (pressed ? 0x80 : 0x00);
-	}
-	
-	/**
-	 * Button register
-	 *
-	 * @param	button	Paddle button
-	 */
-	public int getButtonRegister(int button) {
-		return buttonRegister[button];
-	}
+    /**
+     * Paddle class constructor
+     *
+     * @param    apple    The EmAppleII instance
+     */
+    public Paddle(EmAppleII apple) {
+        this.apple = apple;
 
-	/**
-	 * Set paddle position
-	 *
-	 * @param	address	Address
-	 * @param	value	Value
-	 */
-	public void setPaddlePos(int paddle, int value) {
-		/*
-		 * Magic formula, see ROM $FB1E-$FB2E,
-		 * We calculate the numbers of cycles after which
-		 * the RC circuit of a triggered paddle will discharge.
-		 */
-		paddleClockInc[paddle] = value * 11 + 8;
-	}
-	
-	/**
-	 * Trigger paddle register
-	 *
-	 * @param	address	Address
-	 * @param	value	Value
-	 */
-	public void triggerRegister() {
-		paddleClockEvent[0] = apple.clock + paddleClockInc[0];
-		paddleClockEvent[1] = apple.clock + paddleClockInc[1];
-		paddleClockEvent[2] = apple.clock + paddleClockInc[2];
-		paddleClockEvent[3] = apple.clock + paddleClockInc[3];
-	}
-	
-	/**
-	 * Get paddle register
-	 *
-	 * @param	address	Address
-	 * @param	value	Value
-	 */
-	public int getPaddleRegister(int paddle) {
-		return ((((paddleClockEvent[paddle] - apple.clock) & 0x7fffffff) < 0x40000000) ? 0x80 : 0x00); 
-	}
+        setPaddlePos(0, PADDLE_CENTER);
+        setPaddlePos(1, PADDLE_CENTER);
+        setPaddlePos(2, PADDLE_CENTER);
+        setPaddlePos(3, PADDLE_CENTER);
+    }
+
+    /**
+     * Set button state
+     *
+     * @param    button    Paddle button
+     * @param    state    State
+     */
+    public void setButton(int button, boolean pressed) {
+        buttonRegister[button] = (pressed ? 0x80 : 0x00);
+    }
+
+    /**
+     * Button register
+     *
+     * @param    button    Paddle button
+     */
+    public int getButtonRegister(int button) {
+        return buttonRegister[button];
+    }
+
+    /**
+     * Set paddle position
+     *
+     * @param    address    Address
+     * @param    value    Value
+     */
+    public void setPaddlePos(int paddle, int value) {
+        /*
+         * Magic formula, see ROM $FB1E-$FB2E,
+         * We calculate the numbers of cycles after which
+         * the RC circuit of a triggered paddle will discharge.
+         */
+        paddleClockInc[paddle] = value * 11 + 8;
+    }
+
+    /**
+     * Trigger paddle register
+     *
+     * @param    address    Address
+     * @param    value    Value
+     */
+    public void triggerRegister() {
+        paddleClockEvent[0] = apple.clock + paddleClockInc[0];
+        paddleClockEvent[1] = apple.clock + paddleClockInc[1];
+        paddleClockEvent[2] = apple.clock + paddleClockInc[2];
+        paddleClockEvent[3] = apple.clock + paddleClockInc[3];
+    }
+
+    /**
+     * Get paddle register
+     *
+     * @param    address    Address
+     * @param    value    Value
+     */
+    public int getPaddleRegister(int paddle) {
+        return ((((paddleClockEvent[paddle] - apple.clock) & 0x7fffffff) < 0x40000000) ? 0x80 : 0x00);
+    }
 }
diff --git a/src/main/java/vavi/apps/appleii/Peripheral.java b/src/main/java/vavi/apps/appleii/Peripheral.java
index 67612f4..5983b75 100644
--- a/src/main/java/vavi/apps/appleii/Peripheral.java
+++ b/src/main/java/vavi/apps/appleii/Peripheral.java
@@ -12,25 +12,25 @@ import java.util.Random;
 
 
 public class Peripheral {
-	protected Random rand = new Random();
+    protected Random rand = new Random();
 
     public Peripheral() {
-	}
-	
-    public int ioRead(int address) {
-		return rand.nextInt(256);
     }
-	
+
+    public int ioRead(int address) {
+        return rand.nextInt(256);
+    }
+
     public void ioWrite(int address, int value) {
     }
-	
+
     public int memoryRead(int address) {
-		return 0;
+        return 0;
     }
-	
+
     public void memoryWrite(int address, int value) {
     }
-	
-	public void reset() {
-	}
+
+    public void reset() {
+    }
 }
diff --git a/src/test/java/vavi/apps/appleii/VirtualKeyboard.java b/src/test/java/vavi/apps/appleii/VirtualKeyboard.java
index 530ed59..82a3704 100644
--- a/src/test/java/vavi/apps/appleii/VirtualKeyboard.java
+++ b/src/test/java/vavi/apps/appleii/VirtualKeyboard.java
@@ -1,5 +1,5 @@
 /*
- * $LastChangedDate: 2005-11-21 02:11:20 +0900 (�? 21 11 2005) $  
+ * $LastChangedDate: 2005-11-21 02:11:20 +0900 (�? 21 11 2005) $
  *
  * Copyright  1990-2006 Sun Microsystems, Inc. All rights reserved.
  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
@@ -17,7 +17,7 @@ import java.awt.event.KeyEvent;
 
 /**
  * This is a popup layer that handles a sub-popup within the text tfContext
- * 
+ *
  * @author Amir Uval
  */
 
@@ -72,7 +72,7 @@ class VirtualKeyboard {
 
     /**
      * Virtual Keyboard constructor.
-     * 
+     *
      * @param keys array of available keys for the keyboard
      * @param vkl the virtual keyboard listener
      * @param displayTextArea flag to indicate whether to display the text area
@@ -192,7 +192,7 @@ System.err.println("Please split your keyboard array to multiple arrays.");
 
     /**
      * Checks if the virtual keyboard is enabled.
-     * 
+     *
      * @return <code>true</code> if the virtual keyboard is enabled,
      *         <code>false</code> otherwise.
      */
@@ -202,7 +202,7 @@ System.err.println("Please split your keyboard array to multiple arrays.");
 
     /**
      * Checks if the virtual keyboard is enabled.
-     * 
+     *
      * @return <code>true</code> if the virtual keyboard is enabled,
      *         <code>false</code> otherwise.
      */
@@ -212,7 +212,7 @@ System.err.println("Please split your keyboard array to multiple arrays.");
 
     /**
      * Checks if the virtual keyboard is opened automatically.
-     * 
+     *
      * @return <code>true</code> if the virtual keyboard is opened
      *         automatically, <code>false</code> otherwise.
      */
@@ -222,7 +222,7 @@ System.err.println("Please split your keyboard array to multiple arrays.");
 
     /**
      * traverse the virtual keyboard according to key pressed.
-     * 
+     *
      * @param type type of keypress
      * @param keyCode key code of key pressed
      */
@@ -394,7 +394,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * paint the virtual keyboard on the screen
-     * 
+     *
      * @param g The graphics context to paint to
      */
     protected void paint(Graphics g) {
@@ -426,7 +426,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * Draw the text field of the virtual keyboard.
-     * 
+     *
      * @param g The graphics context to paint to
      */
     void drawTextField(Graphics g) {
@@ -456,7 +456,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * draw keyboard keys
-     * 
+     *
      * @param g The graphics context to paint to
      */
     void drawKeys(Graphics g) {
@@ -491,7 +491,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * draw keyboard meta keys
-     * 
+     *
      * @param g The graphics context to paint to
      */
     void drawMetaKeys(Graphics g) {
@@ -529,7 +529,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * draw a border
-     * 
+     *
      * @param g The graphics context to paint to
      * @param x1 x-coordinate of the button's location
      * @param y1 y-coordinate of the button's location
@@ -549,7 +549,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * draw a sunken border
-     * 
+     *
      * @param g The graphics context to paint to
      * @param x1 x-coordinate of the button's location
      * @param y1 y-coordinate of the button's location
@@ -575,7 +575,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * draw a button
-     * 
+     *
      * @param g The graphics context to paint to
      * @param x x-coordinate of the button's location
      * @param y y-coordinate of the button's location
@@ -599,7 +599,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * draw a beveled button
-     * 
+     *
      * @param g The graphics context to paint to
      * @param x x-coordinate of the button's location
      * @param y y-coordinate of the button's location
@@ -627,12 +627,12 @@ System.err.println("VirtualK: keyCode=" + keyCode);
 
     /**
      * Helper function to determine the itemIndex at the x,y position
-     * 
+     *
      * @param x,y pointer coordinates in menuLayer's space (0,0 means left-top
      *            corner) both value can be negative as menuLayer handles the
      *            pointer event outside its bounds
      * @return menuItem's index since 0, or PRESS_OUT_OF_BOUNDS, PRESS_ON_TITLE
-     * 
+     *
      */
     private boolean isKeyAtPointerPosition(int x, int y) {
         int tmpX, tmpY, tmp;
@@ -696,7 +696,7 @@ System.err.println("VirtualK: keyCode=" + keyCode);
      * and the x,y location in the layer at which the event occurred. Important
      * : the x,y location of the pen tap will already be translated into the
      * coordinate space of the layer.
-     * 
+     *
      * @param type the type of pen event
      * @param x the x coordinate of the event
      * @param y the y coordinate of the event
@@ -774,7 +774,7 @@ class VirtualKeyboardException extends Exception {
      * The error message string <code>s</code> can later be retrieved by the
      * <code>{@link java.lang.Throwable#getMessage}</code> method of class
      * <code>java.lang.Throwable</code>.
-     * 
+     *
      * @param s the detail message.
      */
     public VirtualKeyboardException(String s) {
diff --git a/src/test/java/vavi/apps/appleii/VirtualKeyboardListener.java b/src/test/java/vavi/apps/appleii/VirtualKeyboardListener.java
index 65eff02..52a1eb6 100644
--- a/src/test/java/vavi/apps/appleii/VirtualKeyboardListener.java
+++ b/src/test/java/vavi/apps/appleii/VirtualKeyboardListener.java
@@ -1,5 +1,5 @@
 /*
- * $LastChangedDate: 2005-09-18 20:31:12 +0900 (일, 18 9 2005) $  
+ * $LastChangedDate: 2005-09-18 20:31:12 +0900 (일, 18 9 2005) $
  *
  * Copyright  1990-2006 Sun Microsystems, Inc. All rights reserved.
  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
@@ -15,39 +15,39 @@ import java.awt.Graphics;
  * @author Amir Uval
  */
 interface VirtualKeyboardListener {
-                
+
     /**
      * key input callback
      */
     public void virtualKeyEntered(int type, char c);
-    
+
     /**
      * meta key event callback
      */
     public void virtualMetaKeyEntered(int metaKey);
-    
+
     /**
      * a callback used to draw the text entered by the virtual keyboard - on the
      * keyboard text area.
-     * In KeyboardLayer, it is implemented by passing the call to 
+     * In KeyboardLayer, it is implemented by passing the call to
      * TextField's paint(..)
      */
     public void paintTextOnly(Graphics g, int width, int height);
 
     public void paintCandidateBar(Graphics g, int width, int height);
-    
+
     /**
      * should return the width of the owner Displayable
      */
     public int getAvailableWidth();
-    
+
     /**
      * should return the height of the owner Displayable
      */
-    public int getAvailableHeight(); 
-    
+    public int getAvailableHeight();
+
     /**
-     * should trigger a requestRepaint() call to schedule a 
+     * should trigger a requestRepaint() call to schedule a
      * paint() of the VirtualKeyboard
      */
     public void repaintVK();
diff --git a/src/test/java/vavi/apps/appleii/VirtualKeyboardTest.java b/src/test/java/vavi/apps/appleii/VirtualKeyboardTest.java
index 8d4adb6..4296dd3 100644
--- a/src/test/java/vavi/apps/appleii/VirtualKeyboardTest.java
+++ b/src/test/java/vavi/apps/appleii/VirtualKeyboardTest.java
@@ -18,7 +18,7 @@ import junit.framework.TestCase;
 
 
 /**
- * VirtualKeyboardTest. 
+ * VirtualKeyboardTest.
  *
  * @author <a href="mailto:vavivavi@yahoo.co.jp">Naohide Sano</a> (nsano)
  * @version 0.00 080924 nsano initial version <br>
@@ -104,7 +104,7 @@ public class VirtualKeyboardTest extends TestCase {
         keys[1][48] = '&';
         keys[1][49] = '*';
         keys[1][50] = '/';
-        
+
         // Roman, upper case
         keys[2] = new char[51]; // numerals
         keys[2][0] = 'Q';