Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / Octane / gbemu-part2.js
1 // Portions copyright 2013 Google, Inc
2
3 // Copyright (C) 2010 - 2012 Grant Galitz
4 // This program is free software; you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License version 2 as
6 // published by the Free Software Foundation.
7 // The full license is available at http://www.gnu.org/licenses/gpl.html
8 // This program is distributed in the hope that it will be useful, but
9 // WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 // See the GNU General Public License for more details.
12
13 // The code has been adapted for use as a benchmark by Google.
14
15 // Previous files are in gbemu-part1.js, since they need to run in sloppy mode.
16
17 // Start of js/GameBoyCore.js file.
18
19 "use strict";
20 /*
21  * JavaScript GameBoy Color Emulator
22  * Copyright (C) 2010 - 2012 Grant Galitz
23  *
24  * This program is free software; you can redistribute it and/or
25  * modify it under the terms of the GNU General Public License
26  * version 2 as published by the Free Software Foundation.
27  * The full license is available at http://www.gnu.org/licenses/gpl.html
28  *
29  * This program is distributed in the hope that it will be useful,
30  * but WITHOUT ANY WARRANTY; without even the implied warranty of
31  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32  * GNU General Public License for more details.
33  *
34  */
35 function GameBoyCore(canvas, ROMImage) {
36   //Params, etc...
37   this.canvas = canvas;            //Canvas DOM object for drawing out the graphics to.
38   this.drawContext = null;          // LCD Context
39   this.ROMImage = ROMImage;          //The game's ROM.
40   //CPU Registers and Flags:
41   this.registerA = 0x01;             //Register A (Accumulator)
42   this.FZero = true;               //Register F  - Result was zero
43   this.FSubtract = false;            //Register F  - Subtraction was executed
44   this.FHalfCarry = true;            //Register F  - Half carry or half borrow
45   this.FCarry = true;              //Register F  - Carry or borrow
46   this.registerB = 0x00;            //Register B
47   this.registerC = 0x13;            //Register C
48   this.registerD = 0x00;            //Register D
49   this.registerE = 0xD8;            //Register E
50   this.registersHL = 0x014D;          //Registers H and L combined
51   this.stackPointer = 0xFFFE;          //Stack Pointer
52   this.programCounter = 0x0100;        //Program Counter
53   //Some CPU Emulation State Variables:
54   this.CPUCyclesTotal = 0;          //Relative CPU clocking to speed set, rounded appropriately.
55   this.CPUCyclesTotalBase = 0;        //Relative CPU clocking to speed set base.
56   this.CPUCyclesTotalCurrent = 0;        //Relative CPU clocking to speed set, the directly used value.
57   this.CPUCyclesTotalRoundoff = 0;      //Clocking per iteration rounding catch.
58   this.baseCPUCyclesPerIteration = 0;    //CPU clocks per iteration at 1x speed.
59   this.remainingClocks = 0;          //HALT clocking overrun carry over.
60   this.inBootstrap = true;          //Whether we're in the GBC boot ROM.
61   this.usedBootROM = false;          //Updated upon ROM loading...
62   this.usedGBCBootROM = false;        //Did we boot to the GBC boot ROM?
63   this.halt = false;              //Has the CPU been suspended until the next interrupt?
64   this.skipPCIncrement = false;        //Did we trip the DMG Halt bug?
65   this.stopEmulator = 3;            //Has the emulation been paused or a frame has ended?
66   this.IME = true;              //Are interrupts enabled?
67   this.IRQLineMatched = 0;          //CPU IRQ assertion.
68   this.interruptsRequested = 0;        //IF Register
69   this.interruptsEnabled = 0;          //IE Register
70   this.hdmaRunning = false;          //HDMA Transfer Flag - GBC only
71   this.CPUTicks = 0;              //The number of clock cycles emulated.
72   this.doubleSpeedShifter = 0;        //GBC double speed clocking shifter.
73   this.JoyPad = 0xFF;              //Joypad State (two four-bit states actually)
74   this.CPUStopped = false;          //CPU STOP status.
75   //Main RAM, MBC RAM, GBC Main RAM, VRAM, etc.
76   this.memoryReader = [];            //Array of functions mapped to read back memory
77   this.memoryWriter = [];            //Array of functions mapped to write to memory
78   this.memoryHighReader = [];          //Array of functions mapped to read back 0xFFXX memory
79   this.memoryHighWriter = [];          //Array of functions mapped to write to 0xFFXX memory
80   this.ROM = [];                //The full ROM file dumped to an array.
81   this.memory = [];              //Main Core Memory
82   this.MBCRam = [];              //Switchable RAM (Used by games for more RAM) for the main memory range 0xA000 - 0xC000.
83   this.VRAM = [];                //Extra VRAM bank for GBC.
84   this.GBCMemory = [];            //GBC main RAM Banks
85   this.MBC1Mode = false;            //MBC1 Type (4/32, 16/8)
86   this.MBCRAMBanksEnabled = false;      //MBC RAM Access Control.
87   this.currMBCRAMBank = 0;          //MBC Currently Indexed RAM Bank
88   this.currMBCRAMBankPosition = -0xA000;    //MBC Position Adder;
89   this.cGBC = false;              //GameBoy Color detection.
90   this.gbcRamBank = 1;            //Currently Switched GameBoy Color ram bank
91   this.gbcRamBankPosition = -0xD000;      //GBC RAM offset from address start.
92   this.gbcRamBankPositionECHO = -0xF000;    //GBC RAM (ECHO mirroring) offset from address start.
93   this.RAMBanks = [0, 1, 2, 4, 16];      //Used to map the RAM banks to maximum size the MBC used can do.
94   this.ROMBank1offs = 0;            //Offset of the ROM bank switching.
95   this.currentROMBank = 0;          //The parsed current ROM bank selection.
96   this.cartridgeType = 0;            //Cartridge Type
97   this.name = "";                //Name of the game
98   this.gameCode = "";              //Game code (Suffix for older games)
99   this.fromSaveState = false;          //A boolean to see if this was loaded in as a save state.
100   this.savedStateFileName = "";        //When loaded in as a save state, this will not be empty.
101   this.STATTracker = 0;            //Tracker for STAT triggering.
102   this.modeSTAT = 0;              //The scan line mode (for lines 1-144 it's 2-3-0, for 145-154 it's 1)
103   this.spriteCount = 252;            //Mode 3 extra clocking counter (Depends on how many sprites are on the current line.).
104   this.LYCMatchTriggerSTAT = false;      //Should we trigger an interrupt if LY==LYC?
105   this.mode2TriggerSTAT = false;        //Should we trigger an interrupt if in mode 2?
106   this.mode1TriggerSTAT = false;        //Should we trigger an interrupt if in mode 1?
107   this.mode0TriggerSTAT = false;        //Should we trigger an interrupt if in mode 0?
108   this.LCDisOn = false;            //Is the emulated LCD controller on?
109   this.LINECONTROL = [];            //Array of functions to handle each scan line we do (onscreen + offscreen)
110   this.DISPLAYOFFCONTROL = [function (parentObj) {
111     //Array of line 0 function to handle the LCD controller when it's off (Do nothing!).
112   }];
113   this.LCDCONTROL = null;            //Pointer to either LINECONTROL or DISPLAYOFFCONTROL.
114   this.initializeLCDController();        //Compile the LCD controller functions.
115   //RTC (Real Time Clock for MBC3):
116   this.RTCisLatched = false;
117   this.latchedSeconds = 0;          //RTC latched seconds.
118   this.latchedMinutes = 0;          //RTC latched minutes.
119   this.latchedHours = 0;            //RTC latched hours.
120   this.latchedLDays = 0;            //RTC latched lower 8-bits of the day counter.
121   this.latchedHDays = 0;            //RTC latched high-bit of the day counter.
122   this.RTCSeconds = 0;            //RTC seconds counter.
123   this.RTCMinutes = 0;            //RTC minutes counter.
124   this.RTCHours = 0;              //RTC hours counter.
125   this.RTCDays = 0;              //RTC days counter.
126   this.RTCDayOverFlow = false;        //Did the RTC overflow and wrap the day counter?
127   this.RTCHALT = false;            //Is the RTC allowed to clock up?
128   //Gyro:
129   this.highX = 127;
130   this.lowX = 127;
131   this.highY = 127;
132   this.lowY = 127;
133   //Sound variables:
134   this.audioHandle = null;            //XAudioJS handle
135   this.numSamplesTotal = 0;            //Length of the sound buffers.
136   this.sampleSize = 0;              //Length of the sound buffer for one channel.
137   this.dutyLookup = [                //Map the duty values given to ones we can work with.
138     [false, false, false, false, false, false, false, true],
139     [true, false, false, false, false, false, false, true],
140     [true, false, false, false, false, true, true, true],
141     [false, true, true, true, true, true, true, false]
142   ];
143   this.currentBuffer = [];            //The audio buffer we're working on.
144   this.bufferContainAmount = 0;          //Buffer maintenance metric.
145   this.LSFR15Table = null;
146   this.LSFR7Table = null;
147   this.noiseSampleTable = null;
148   this.initializeAudioStartState();
149   this.soundMasterEnabled = false;      //As its name implies
150   this.channel3PCM = null;          //Channel 3 adjusted sample buffer.
151   //Vin Shit:
152   this.VinLeftChannelMasterVolume = 8;    //Computed post-mixing volume.
153   this.VinRightChannelMasterVolume = 8;    //Computed post-mixing volume.
154   //Channel paths enabled:
155   this.leftChannel1 = false;
156   this.leftChannel2 = false;
157   this.leftChannel3 = false;
158   this.leftChannel4 = false;
159   this.rightChannel1 = false;
160   this.rightChannel2 = false;
161   this.rightChannel3 = false;
162   this.rightChannel4 = false;
163   //Channel output level caches:
164   this.channel1currentSampleLeft = 0;
165   this.channel1currentSampleRight = 0;
166   this.channel2currentSampleLeft = 0;
167   this.channel2currentSampleRight = 0;
168   this.channel3currentSampleLeft = 0;
169   this.channel3currentSampleRight = 0;
170   this.channel4currentSampleLeft = 0;
171   this.channel4currentSampleRight = 0;
172   this.channel1currentSampleLeftSecondary = 0;
173   this.channel1currentSampleRightSecondary = 0;
174   this.channel2currentSampleLeftSecondary = 0;
175   this.channel2currentSampleRightSecondary = 0;
176   this.channel3currentSampleLeftSecondary = 0;
177   this.channel3currentSampleRightSecondary = 0;
178   this.channel4currentSampleLeftSecondary = 0;
179   this.channel4currentSampleRightSecondary = 0;
180   this.channel1currentSampleLeftTrimary = 0;
181   this.channel1currentSampleRightTrimary = 0;
182   this.channel2currentSampleLeftTrimary = 0;
183   this.channel2currentSampleRightTrimary = 0;
184   this.mixerOutputCache = 0;
185   //Pre-multipliers to cache some calculations:
186   this.initializeTiming();
187   this.machineOut = 0;        //Premultiplier for audio samples per instruction.
188   //Audio generation counters:
189   this.audioTicks = 0;        //Used to sample the audio system every x CPU instructions.
190   this.audioIndex = 0;        //Used to keep alignment on audio generation.
191   this.rollover = 0;          //Used to keep alignment on the number of samples to output (Realign from counter alias).
192   //Timing Variables
193   this.emulatorTicks = 0;        //Times for how many instructions to execute before ending the loop.
194   this.DIVTicks = 56;          //DIV Ticks Counter (Invisible lower 8-bit)
195   this.LCDTicks = 60;          //Counter for how many instructions have been executed on a scanline so far.
196   this.timerTicks = 0;        //Counter for the TIMA timer.
197   this.TIMAEnabled = false;      //Is TIMA enabled?
198   this.TACClocker = 1024;        //Timer Max Ticks
199   this.serialTimer = 0;        //Serial IRQ Timer
200   this.serialShiftTimer = 0;      //Serial Transfer Shift Timer
201   this.serialShiftTimerAllocated = 0;  //Serial Transfer Shift Timer Refill
202   this.IRQEnableDelay = 0;      //Are the interrupts on queue to be enabled?
203   var dateVar = new_Date();     // The line is changed for benchmarking.
204   this.lastIteration = dateVar.getTime();//The last time we iterated the main loop.
205   dateVar = new_Date();         // The line is changed for benchmarking.
206   this.firstIteration = dateVar.getTime();
207   this.iterations = 0;
208   this.actualScanLine = 0;      //Actual scan line...
209   this.lastUnrenderedLine = 0;    //Last rendered scan line...
210   this.queuedScanLines = 0;
211   this.totalLinesPassed = 0;
212   this.haltPostClocks = 0;      //Post-Halt clocking.
213   //ROM Cartridge Components:
214   this.cMBC1 = false;          //Does the cartridge use MBC1?
215   this.cMBC2 = false;          //Does the cartridge use MBC2?
216   this.cMBC3 = false;          //Does the cartridge use MBC3?
217   this.cMBC5 = false;          //Does the cartridge use MBC5?
218   this.cMBC7 = false;          //Does the cartridge use MBC7?
219   this.cSRAM = false;          //Does the cartridge use save RAM?
220   this.cMMMO1 = false;        //...
221   this.cRUMBLE = false;        //Does the cartridge use the RUMBLE addressing (modified MBC5)?
222   this.cCamera = false;        //Is the cartridge actually a GameBoy Camera?
223   this.cTAMA5 = false;        //Does the cartridge use TAMA5? (Tamagotchi Cartridge)
224   this.cHuC3 = false;          //Does the cartridge use HuC3 (Hudson Soft / modified MBC3)?
225   this.cHuC1 = false;          //Does the cartridge use HuC1 (Hudson Soft / modified MBC1)?
226   this.cTIMER = false;        //Does the cartridge have an RTC?
227   this.ROMBanks = [          // 1 Bank = 16 KBytes = 256 Kbits
228     2, 4, 8, 16, 32, 64, 128, 256, 512
229   ];
230   this.ROMBanks[0x52] = 72;
231   this.ROMBanks[0x53] = 80;
232   this.ROMBanks[0x54] = 96;
233   this.numRAMBanks = 0;          //How many RAM banks were actually allocated?
234   ////Graphics Variables
235   this.currVRAMBank = 0;          //Current VRAM bank for GBC.
236   this.backgroundX = 0;          //Register SCX (X-Scroll)
237   this.backgroundY = 0;          //Register SCY (Y-Scroll)
238   this.gfxWindowDisplay = false;      //Is the windows enabled?
239   this.gfxSpriteShow = false;        //Are sprites enabled?
240   this.gfxSpriteNormalHeight = true;    //Are we doing 8x8 or 8x16 sprites?
241   this.bgEnabled = true;          //Is the BG enabled?
242   this.BGPriorityEnabled = true;      //Can we flag the BG for priority over sprites?
243   this.gfxWindowCHRBankPosition = 0;    //The current bank of the character map the window uses.
244   this.gfxBackgroundCHRBankPosition = 0;  //The current bank of the character map the BG uses.
245   this.gfxBackgroundBankOffset = 0x80;  //Fast mapping of the tile numbering/
246   this.windowY = 0;            //Current Y offset of the window.
247   this.windowX = 0;            //Current X offset of the window.
248   this.drewBlank = 0;            //To prevent the repeating of drawing a blank screen.
249   this.drewFrame = false;          //Throttle how many draws we can do to once per iteration.
250   this.midScanlineOffset = -1;      //mid-scanline rendering offset.
251   this.pixelEnd = 0;            //track the x-coord limit for line rendering (mid-scanline usage).
252   this.currentX = 0;            //The x-coord we left off at for mid-scanline rendering.
253   //BG Tile Pointer Caches:
254   this.BGCHRBank1 = null;
255   this.BGCHRBank2 = null;
256   this.BGCHRCurrentBank = null;
257   //Tile Data Cache:
258   this.tileCache = null;
259   //Palettes:
260   this.colors = [0xEFFFDE, 0xADD794, 0x529273, 0x183442];      //"Classic" GameBoy palette colors.
261   this.OBJPalette = null;
262   this.BGPalette = null;
263   this.gbcOBJRawPalette = null;
264   this.gbcBGRawPalette = null;
265   this.gbOBJPalette = null;
266   this.gbBGPalette = null;
267   this.gbcOBJPalette = null;
268   this.gbcBGPalette = null;
269   this.gbBGColorizedPalette = null;
270   this.gbOBJColorizedPalette = null;
271   this.cachedBGPaletteConversion = null;
272   this.cachedOBJPaletteConversion = null;
273   this.updateGBBGPalette = this.updateGBRegularBGPalette;
274   this.updateGBOBJPalette = this.updateGBRegularOBJPalette;
275   this.colorizedGBPalettes = false;
276   this.BGLayerRender = null;      //Reference to the BG rendering function.
277   this.WindowLayerRender = null;    //Reference to the window rendering function.
278   this.SpriteLayerRender = null;    //Reference to the OAM rendering function.
279   this.frameBuffer = [];        //The internal frame-buffer.
280   this.swizzledFrame = null;      //The secondary gfx buffer that holds the converted RGBA values.
281   this.canvasBuffer = null;      //imageData handle
282   this.pixelStart = 0;        //Temp variable for holding the current working framebuffer offset.
283   //Variables used for scaling in JS:
284   this.onscreenWidth = this.offscreenWidth = 160;
285   this.onscreenHeight = this.offScreenheight = 144;
286   this.offscreenRGBCount = this.onscreenWidth * this.onscreenHeight * 4;
287   //Initialize the white noise cache tables ahead of time:
288   this.intializeWhiteNoise();
289 }
290
291 // Start of code changed for benchmarking (removed ROM):
292 GameBoyCore.prototype.GBBOOTROM = [];
293 GameBoyCore.prototype.GBCBOOTROM = [];
294 // End of code changed for benchmarking.
295
296 GameBoyCore.prototype.ffxxDump = [  //Dump of the post-BOOT I/O register state (From gambatte):
297   0x0F, 0x00, 0x7C, 0xFF, 0x00, 0x00, 0x00, 0xF8,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01,
298   0x80, 0xBF, 0xF3, 0xFF, 0xBF, 0xFF, 0x3F, 0x00,   0xFF, 0xBF, 0x7F, 0xFF, 0x9F, 0xFF, 0xBF, 0xFF,
299   0xFF, 0x00, 0x00, 0xBF, 0x77, 0xF3, 0xF1, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
300   0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,   0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
301   0x91, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC,   0x00, 0x00, 0x00, 0x00, 0xFF, 0x7E, 0xFF, 0xFE,
302   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
303   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,   0xC0, 0xFF, 0xC1, 0x00, 0xFE, 0xFF, 0xFF, 0xFF,
304   0xF8, 0xFF, 0x00, 0x00, 0x00, 0x8F, 0x00, 0x00,   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
305   0xCE, 0xED, 0x66, 0x66, 0xCC, 0x0D, 0x00, 0x0B,   0x03, 0x73, 0x00, 0x83, 0x00, 0x0C, 0x00, 0x0D,
306   0x00, 0x08, 0x11, 0x1F, 0x88, 0x89, 0x00, 0x0E,   0xDC, 0xCC, 0x6E, 0xE6, 0xDD, 0xDD, 0xD9, 0x99,
307   0xBB, 0xBB, 0x67, 0x63, 0x6E, 0x0E, 0xEC, 0xCC,   0xDD, 0xDC, 0x99, 0x9F, 0xBB, 0xB9, 0x33, 0x3E,
308   0x45, 0xEC, 0x52, 0xFA, 0x08, 0xB7, 0x07, 0x5D,   0x01, 0xFD, 0xC0, 0xFF, 0x08, 0xFC, 0x00, 0xE5,
309   0x0B, 0xF8, 0xC2, 0xCE, 0xF4, 0xF9, 0x0F, 0x7F,   0x45, 0x6D, 0x3D, 0xFE, 0x46, 0x97, 0x33, 0x5E,
310   0x08, 0xEF, 0xF1, 0xFF, 0x86, 0x83, 0x24, 0x74,   0x12, 0xFC, 0x00, 0x9F, 0xB4, 0xB7, 0x06, 0xD5,
311   0xD0, 0x7A, 0x00, 0x9E, 0x04, 0x5F, 0x41, 0x2F,   0x1D, 0x77, 0x36, 0x75, 0x81, 0xAA, 0x70, 0x3A,
312   0x98, 0xD1, 0x71, 0x02, 0x4D, 0x01, 0xC1, 0xFF,   0x0D, 0x00, 0xD3, 0x05, 0xF9, 0x00, 0x0B, 0x00
313 ];
314 GameBoyCore.prototype.OPCODE = [
315   //NOP
316   //#0x00:
317   function (parentObj) {
318     //Do Nothing...
319   },
320   //LD BC, nn
321   //#0x01:
322   function (parentObj) {
323     parentObj.registerC = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
324     parentObj.registerB = parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF);
325     parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
326   },
327   //LD (BC), A
328   //#0x02:
329   function (parentObj) {
330     parentObj.memoryWrite((parentObj.registerB << 8) | parentObj.registerC, parentObj.registerA);
331   },
332   //INC BC
333   //#0x03:
334   function (parentObj) {
335     var temp_var = ((parentObj.registerB << 8) | parentObj.registerC) + 1;
336     parentObj.registerB = (temp_var >> 8) & 0xFF;
337     parentObj.registerC = temp_var & 0xFF;
338   },
339   //INC B
340   //#0x04:
341   function (parentObj) {
342     parentObj.registerB = (parentObj.registerB + 1) & 0xFF;
343     parentObj.FZero = (parentObj.registerB == 0);
344     parentObj.FHalfCarry = ((parentObj.registerB & 0xF) == 0);
345     parentObj.FSubtract = false;
346   },
347   //DEC B
348   //#0x05:
349   function (parentObj) {
350     parentObj.registerB = (parentObj.registerB - 1) & 0xFF;
351     parentObj.FZero = (parentObj.registerB == 0);
352     parentObj.FHalfCarry = ((parentObj.registerB & 0xF) == 0xF);
353     parentObj.FSubtract = true;
354   },
355   //LD B, n
356   //#0x06:
357   function (parentObj) {
358     parentObj.registerB = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
359     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
360   },
361   //RLCA
362   //#0x07:
363   function (parentObj) {
364     parentObj.FCarry = (parentObj.registerA > 0x7F);
365     parentObj.registerA = ((parentObj.registerA << 1) & 0xFF) | (parentObj.registerA >> 7);
366     parentObj.FZero = parentObj.FSubtract = parentObj.FHalfCarry = false;
367   },
368   //LD (nn), SP
369   //#0x08:
370   function (parentObj) {
371     var temp_var = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
372     parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
373     parentObj.memoryWrite(temp_var, parentObj.stackPointer & 0xFF);
374     parentObj.memoryWrite((temp_var + 1) & 0xFFFF, parentObj.stackPointer >> 8);
375   },
376   //ADD HL, BC
377   //#0x09:
378   function (parentObj) {
379     var dirtySum = parentObj.registersHL + ((parentObj.registerB << 8) | parentObj.registerC);
380     parentObj.FHalfCarry = ((parentObj.registersHL & 0xFFF) > (dirtySum & 0xFFF));
381     parentObj.FCarry = (dirtySum > 0xFFFF);
382     parentObj.registersHL = dirtySum & 0xFFFF;
383     parentObj.FSubtract = false;
384   },
385   //LD A, (BC)
386   //#0x0A:
387   function (parentObj) {
388     parentObj.registerA = parentObj.memoryRead((parentObj.registerB << 8) | parentObj.registerC);
389   },
390   //DEC BC
391   //#0x0B:
392   function (parentObj) {
393     var temp_var = (((parentObj.registerB << 8) | parentObj.registerC) - 1) & 0xFFFF;
394     parentObj.registerB = temp_var >> 8;
395     parentObj.registerC = temp_var & 0xFF;
396   },
397   //INC C
398   //#0x0C:
399   function (parentObj) {
400     parentObj.registerC = (parentObj.registerC + 1) & 0xFF;
401     parentObj.FZero = (parentObj.registerC == 0);
402     parentObj.FHalfCarry = ((parentObj.registerC & 0xF) == 0);
403     parentObj.FSubtract = false;
404   },
405   //DEC C
406   //#0x0D:
407   function (parentObj) {
408     parentObj.registerC = (parentObj.registerC - 1) & 0xFF;
409     parentObj.FZero = (parentObj.registerC == 0);
410     parentObj.FHalfCarry = ((parentObj.registerC & 0xF) == 0xF);
411     parentObj.FSubtract = true;
412   },
413   //LD C, n
414   //#0x0E:
415   function (parentObj) {
416     parentObj.registerC = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
417     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
418   },
419   //RRCA
420   //#0x0F:
421   function (parentObj) {
422     parentObj.registerA = (parentObj.registerA >> 1) | ((parentObj.registerA & 1) << 7);
423     parentObj.FCarry = (parentObj.registerA > 0x7F);
424     parentObj.FZero = parentObj.FSubtract = parentObj.FHalfCarry = false;
425   },
426   //STOP
427   //#0x10:
428   function (parentObj) {
429     if (parentObj.cGBC) {
430       if ((parentObj.memory[0xFF4D] & 0x01) == 0x01) {    //Speed change requested.
431         if (parentObj.memory[0xFF4D] > 0x7F) {        //Go back to single speed mode.
432           cout("Going into single clock speed mode.", 0);
433           parentObj.doubleSpeedShifter = 0;
434           parentObj.memory[0xFF4D] &= 0x7F;        //Clear the double speed mode flag.
435         }
436         else {                        //Go to double speed mode.
437           cout("Going into double clock speed mode.", 0);
438           parentObj.doubleSpeedShifter = 1;
439           parentObj.memory[0xFF4D] |= 0x80;        //Set the double speed mode flag.
440         }
441         parentObj.memory[0xFF4D] &= 0xFE;          //Reset the request bit.
442       }
443       else {
444         parentObj.handleSTOP();
445       }
446     }
447     else {
448       parentObj.handleSTOP();
449     }
450   },
451   //LD DE, nn
452   //#0x11:
453   function (parentObj) {
454     parentObj.registerE = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
455     parentObj.registerD = parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF);
456     parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
457   },
458   //LD (DE), A
459   //#0x12:
460   function (parentObj) {
461     parentObj.memoryWrite((parentObj.registerD << 8) | parentObj.registerE, parentObj.registerA);
462   },
463   //INC DE
464   //#0x13:
465   function (parentObj) {
466     var temp_var = ((parentObj.registerD << 8) | parentObj.registerE) + 1;
467     parentObj.registerD = (temp_var >> 8) & 0xFF;
468     parentObj.registerE = temp_var & 0xFF;
469   },
470   //INC D
471   //#0x14:
472   function (parentObj) {
473     parentObj.registerD = (parentObj.registerD + 1) & 0xFF;
474     parentObj.FZero = (parentObj.registerD == 0);
475     parentObj.FHalfCarry = ((parentObj.registerD & 0xF) == 0);
476     parentObj.FSubtract = false;
477   },
478   //DEC D
479   //#0x15:
480   function (parentObj) {
481     parentObj.registerD = (parentObj.registerD - 1) & 0xFF;
482     parentObj.FZero = (parentObj.registerD == 0);
483     parentObj.FHalfCarry = ((parentObj.registerD & 0xF) == 0xF);
484     parentObj.FSubtract = true;
485   },
486   //LD D, n
487   //#0x16:
488   function (parentObj) {
489     parentObj.registerD = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
490     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
491   },
492   //RLA
493   //#0x17:
494   function (parentObj) {
495     var carry_flag = (parentObj.FCarry) ? 1 : 0;
496     parentObj.FCarry = (parentObj.registerA > 0x7F);
497     parentObj.registerA = ((parentObj.registerA << 1) & 0xFF) | carry_flag;
498     parentObj.FZero = parentObj.FSubtract = parentObj.FHalfCarry = false;
499   },
500   //JR n
501   //#0x18:
502   function (parentObj) {
503     parentObj.programCounter = (parentObj.programCounter + ((parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) << 24) >> 24) + 1) & 0xFFFF;
504   },
505   //ADD HL, DE
506   //#0x19:
507   function (parentObj) {
508     var dirtySum = parentObj.registersHL + ((parentObj.registerD << 8) | parentObj.registerE);
509     parentObj.FHalfCarry = ((parentObj.registersHL & 0xFFF) > (dirtySum & 0xFFF));
510     parentObj.FCarry = (dirtySum > 0xFFFF);
511     parentObj.registersHL = dirtySum & 0xFFFF;
512     parentObj.FSubtract = false;
513   },
514   //LD A, (DE)
515   //#0x1A:
516   function (parentObj) {
517     parentObj.registerA = parentObj.memoryRead((parentObj.registerD << 8) | parentObj.registerE);
518   },
519   //DEC DE
520   //#0x1B:
521   function (parentObj) {
522     var temp_var = (((parentObj.registerD << 8) | parentObj.registerE) - 1) & 0xFFFF;
523     parentObj.registerD = temp_var >> 8;
524     parentObj.registerE = temp_var & 0xFF;
525   },
526   //INC E
527   //#0x1C:
528   function (parentObj) {
529     parentObj.registerE = (parentObj.registerE + 1) & 0xFF;
530     parentObj.FZero = (parentObj.registerE == 0);
531     parentObj.FHalfCarry = ((parentObj.registerE & 0xF) == 0);
532     parentObj.FSubtract = false;
533   },
534   //DEC E
535   //#0x1D:
536   function (parentObj) {
537     parentObj.registerE = (parentObj.registerE - 1) & 0xFF;
538     parentObj.FZero = (parentObj.registerE == 0);
539     parentObj.FHalfCarry = ((parentObj.registerE & 0xF) == 0xF);
540     parentObj.FSubtract = true;
541   },
542   //LD E, n
543   //#0x1E:
544   function (parentObj) {
545     parentObj.registerE = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
546     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
547   },
548   //RRA
549   //#0x1F:
550   function (parentObj) {
551     var carry_flag = (parentObj.FCarry) ? 0x80 : 0;
552     parentObj.FCarry = ((parentObj.registerA & 1) == 1);
553     parentObj.registerA = (parentObj.registerA >> 1) | carry_flag;
554     parentObj.FZero = parentObj.FSubtract = parentObj.FHalfCarry = false;
555   },
556   //JR NZ, n
557   //#0x20:
558   function (parentObj) {
559     if (!parentObj.FZero) {
560       parentObj.programCounter = (parentObj.programCounter + ((parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) << 24) >> 24) + 1) & 0xFFFF;
561       parentObj.CPUTicks += 4;
562     }
563     else {
564       parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
565     }
566   },
567   //LD HL, nn
568   //#0x21:
569   function (parentObj) {
570     parentObj.registersHL = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
571     parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
572   },
573   //LDI (HL), A
574   //#0x22:
575   function (parentObj) {
576     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registerA);
577     parentObj.registersHL = (parentObj.registersHL + 1) & 0xFFFF;
578   },
579   //INC HL
580   //#0x23:
581   function (parentObj) {
582     parentObj.registersHL = (parentObj.registersHL + 1) & 0xFFFF;
583   },
584   //INC H
585   //#0x24:
586   function (parentObj) {
587     var H = ((parentObj.registersHL >> 8) + 1) & 0xFF;
588     parentObj.FZero = (H == 0);
589     parentObj.FHalfCarry = ((H & 0xF) == 0);
590     parentObj.FSubtract = false;
591     parentObj.registersHL = (H << 8) | (parentObj.registersHL & 0xFF);
592   },
593   //DEC H
594   //#0x25:
595   function (parentObj) {
596     var H = ((parentObj.registersHL >> 8) - 1) & 0xFF;
597     parentObj.FZero = (H == 0);
598     parentObj.FHalfCarry = ((H & 0xF) == 0xF);
599     parentObj.FSubtract = true;
600     parentObj.registersHL = (H << 8) | (parentObj.registersHL & 0xFF);
601   },
602   //LD H, n
603   //#0x26:
604   function (parentObj) {
605     parentObj.registersHL = (parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) << 8) | (parentObj.registersHL & 0xFF);
606     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
607   },
608   //DAA
609   //#0x27:
610   function (parentObj) {
611     if (!parentObj.FSubtract) {
612       if (parentObj.FCarry || parentObj.registerA > 0x99) {
613         parentObj.registerA = (parentObj.registerA + 0x60) & 0xFF;
614         parentObj.FCarry = true;
615       }
616       if (parentObj.FHalfCarry || (parentObj.registerA & 0xF) > 0x9) {
617         parentObj.registerA = (parentObj.registerA + 0x06) & 0xFF;
618         parentObj.FHalfCarry = false;
619       }
620     }
621     else if (parentObj.FCarry && parentObj.FHalfCarry) {
622       parentObj.registerA = (parentObj.registerA + 0x9A) & 0xFF;
623       parentObj.FHalfCarry = false;
624     }
625     else if (parentObj.FCarry) {
626       parentObj.registerA = (parentObj.registerA + 0xA0) & 0xFF;
627     }
628     else if (parentObj.FHalfCarry) {
629       parentObj.registerA = (parentObj.registerA + 0xFA) & 0xFF;
630       parentObj.FHalfCarry = false;
631     }
632     parentObj.FZero = (parentObj.registerA == 0);
633   },
634   //JR Z, n
635   //#0x28:
636   function (parentObj) {
637     if (parentObj.FZero) {
638       parentObj.programCounter = (parentObj.programCounter + ((parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) << 24) >> 24) + 1) & 0xFFFF;
639       parentObj.CPUTicks += 4;
640     }
641     else {
642       parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
643     }
644   },
645   //ADD HL, HL
646   //#0x29:
647   function (parentObj) {
648     parentObj.FHalfCarry = ((parentObj.registersHL & 0xFFF) > 0x7FF);
649     parentObj.FCarry = (parentObj.registersHL > 0x7FFF);
650     parentObj.registersHL = (parentObj.registersHL << 1) & 0xFFFF;
651     parentObj.FSubtract = false;
652   },
653   //LDI A, (HL)
654   //#0x2A:
655   function (parentObj) {
656     parentObj.registerA = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
657     parentObj.registersHL = (parentObj.registersHL + 1) & 0xFFFF;
658   },
659   //DEC HL
660   //#0x2B:
661   function (parentObj) {
662     parentObj.registersHL = (parentObj.registersHL - 1) & 0xFFFF;
663   },
664   //INC L
665   //#0x2C:
666   function (parentObj) {
667     var L = (parentObj.registersHL + 1) & 0xFF;
668     parentObj.FZero = (L == 0);
669     parentObj.FHalfCarry = ((L & 0xF) == 0);
670     parentObj.FSubtract = false;
671     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | L;
672   },
673   //DEC L
674   //#0x2D:
675   function (parentObj) {
676     var L = (parentObj.registersHL - 1) & 0xFF;
677     parentObj.FZero = (L == 0);
678     parentObj.FHalfCarry = ((L & 0xF) == 0xF);
679     parentObj.FSubtract = true;
680     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | L;
681   },
682   //LD L, n
683   //#0x2E:
684   function (parentObj) {
685     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
686     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
687   },
688   //CPL
689   //#0x2F:
690   function (parentObj) {
691     parentObj.registerA ^= 0xFF;
692     parentObj.FSubtract = parentObj.FHalfCarry = true;
693   },
694   //JR NC, n
695   //#0x30:
696   function (parentObj) {
697     if (!parentObj.FCarry) {
698       parentObj.programCounter = (parentObj.programCounter + ((parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) << 24) >> 24) + 1) & 0xFFFF;
699       parentObj.CPUTicks += 4;
700     }
701     else {
702       parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
703     }
704   },
705   //LD SP, nn
706   //#0x31:
707   function (parentObj) {
708     parentObj.stackPointer = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
709     parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
710   },
711   //LDD (HL), A
712   //#0x32:
713   function (parentObj) {
714     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registerA);
715     parentObj.registersHL = (parentObj.registersHL - 1) & 0xFFFF;
716   },
717   //INC SP
718   //#0x33:
719   function (parentObj) {
720     parentObj.stackPointer = (parentObj.stackPointer + 1) & 0xFFFF;
721   },
722   //INC (HL)
723   //#0x34:
724   function (parentObj) {
725     var temp_var = (parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) + 1) & 0xFF;
726     parentObj.FZero = (temp_var == 0);
727     parentObj.FHalfCarry = ((temp_var & 0xF) == 0);
728     parentObj.FSubtract = false;
729     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
730   },
731   //DEC (HL)
732   //#0x35:
733   function (parentObj) {
734     var temp_var = (parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) - 1) & 0xFF;
735     parentObj.FZero = (temp_var == 0);
736     parentObj.FHalfCarry = ((temp_var & 0xF) == 0xF);
737     parentObj.FSubtract = true;
738     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
739   },
740   //LD (HL), n
741   //#0x36:
742   function (parentObj) {
743     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter));
744     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
745   },
746   //SCF
747   //#0x37:
748   function (parentObj) {
749     parentObj.FCarry = true;
750     parentObj.FSubtract = parentObj.FHalfCarry = false;
751   },
752   //JR C, n
753   //#0x38:
754   function (parentObj) {
755     if (parentObj.FCarry) {
756       parentObj.programCounter = (parentObj.programCounter + ((parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) << 24) >> 24) + 1) & 0xFFFF;
757       parentObj.CPUTicks += 4;
758     }
759     else {
760       parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
761     }
762   },
763   //ADD HL, SP
764   //#0x39:
765   function (parentObj) {
766     var dirtySum = parentObj.registersHL + parentObj.stackPointer;
767     parentObj.FHalfCarry = ((parentObj.registersHL & 0xFFF) > (dirtySum & 0xFFF));
768     parentObj.FCarry = (dirtySum > 0xFFFF);
769     parentObj.registersHL = dirtySum & 0xFFFF;
770     parentObj.FSubtract = false;
771   },
772   //LDD A, (HL)
773   //#0x3A:
774   function (parentObj) {
775     parentObj.registerA = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
776     parentObj.registersHL = (parentObj.registersHL - 1) & 0xFFFF;
777   },
778   //DEC SP
779   //#0x3B:
780   function (parentObj) {
781     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
782   },
783   //INC A
784   //#0x3C:
785   function (parentObj) {
786     parentObj.registerA = (parentObj.registerA + 1) & 0xFF;
787     parentObj.FZero = (parentObj.registerA == 0);
788     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) == 0);
789     parentObj.FSubtract = false;
790   },
791   //DEC A
792   //#0x3D:
793   function (parentObj) {
794     parentObj.registerA = (parentObj.registerA - 1) & 0xFF;
795     parentObj.FZero = (parentObj.registerA == 0);
796     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) == 0xF);
797     parentObj.FSubtract = true;
798   },
799   //LD A, n
800   //#0x3E:
801   function (parentObj) {
802     parentObj.registerA = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
803     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
804   },
805   //CCF
806   //#0x3F:
807   function (parentObj) {
808     parentObj.FCarry = !parentObj.FCarry;
809     parentObj.FSubtract = parentObj.FHalfCarry = false;
810   },
811   //LD B, B
812   //#0x40:
813   function (parentObj) {
814     //Do nothing...
815   },
816   //LD B, C
817   //#0x41:
818   function (parentObj) {
819     parentObj.registerB = parentObj.registerC;
820   },
821   //LD B, D
822   //#0x42:
823   function (parentObj) {
824     parentObj.registerB = parentObj.registerD;
825   },
826   //LD B, E
827   //#0x43:
828   function (parentObj) {
829     parentObj.registerB = parentObj.registerE;
830   },
831   //LD B, H
832   //#0x44:
833   function (parentObj) {
834     parentObj.registerB = parentObj.registersHL >> 8;
835   },
836   //LD B, L
837   //#0x45:
838   function (parentObj) {
839     parentObj.registerB = parentObj.registersHL & 0xFF;
840   },
841   //LD B, (HL)
842   //#0x46:
843   function (parentObj) {
844     parentObj.registerB = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
845   },
846   //LD B, A
847   //#0x47:
848   function (parentObj) {
849     parentObj.registerB = parentObj.registerA;
850   },
851   //LD C, B
852   //#0x48:
853   function (parentObj) {
854     parentObj.registerC = parentObj.registerB;
855   },
856   //LD C, C
857   //#0x49:
858   function (parentObj) {
859     //Do nothing...
860   },
861   //LD C, D
862   //#0x4A:
863   function (parentObj) {
864     parentObj.registerC = parentObj.registerD;
865   },
866   //LD C, E
867   //#0x4B:
868   function (parentObj) {
869     parentObj.registerC = parentObj.registerE;
870   },
871   //LD C, H
872   //#0x4C:
873   function (parentObj) {
874     parentObj.registerC = parentObj.registersHL >> 8;
875   },
876   //LD C, L
877   //#0x4D:
878   function (parentObj) {
879     parentObj.registerC = parentObj.registersHL & 0xFF;
880   },
881   //LD C, (HL)
882   //#0x4E:
883   function (parentObj) {
884     parentObj.registerC = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
885   },
886   //LD C, A
887   //#0x4F:
888   function (parentObj) {
889     parentObj.registerC = parentObj.registerA;
890   },
891   //LD D, B
892   //#0x50:
893   function (parentObj) {
894     parentObj.registerD = parentObj.registerB;
895   },
896   //LD D, C
897   //#0x51:
898   function (parentObj) {
899     parentObj.registerD = parentObj.registerC;
900   },
901   //LD D, D
902   //#0x52:
903   function (parentObj) {
904     //Do nothing...
905   },
906   //LD D, E
907   //#0x53:
908   function (parentObj) {
909     parentObj.registerD = parentObj.registerE;
910   },
911   //LD D, H
912   //#0x54:
913   function (parentObj) {
914     parentObj.registerD = parentObj.registersHL >> 8;
915   },
916   //LD D, L
917   //#0x55:
918   function (parentObj) {
919     parentObj.registerD = parentObj.registersHL & 0xFF;
920   },
921   //LD D, (HL)
922   //#0x56:
923   function (parentObj) {
924     parentObj.registerD = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
925   },
926   //LD D, A
927   //#0x57:
928   function (parentObj) {
929     parentObj.registerD = parentObj.registerA;
930   },
931   //LD E, B
932   //#0x58:
933   function (parentObj) {
934     parentObj.registerE = parentObj.registerB;
935   },
936   //LD E, C
937   //#0x59:
938   function (parentObj) {
939     parentObj.registerE = parentObj.registerC;
940   },
941   //LD E, D
942   //#0x5A:
943   function (parentObj) {
944     parentObj.registerE = parentObj.registerD;
945   },
946   //LD E, E
947   //#0x5B:
948   function (parentObj) {
949     //Do nothing...
950   },
951   //LD E, H
952   //#0x5C:
953   function (parentObj) {
954     parentObj.registerE = parentObj.registersHL >> 8;
955   },
956   //LD E, L
957   //#0x5D:
958   function (parentObj) {
959     parentObj.registerE = parentObj.registersHL & 0xFF;
960   },
961   //LD E, (HL)
962   //#0x5E:
963   function (parentObj) {
964     parentObj.registerE = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
965   },
966   //LD E, A
967   //#0x5F:
968   function (parentObj) {
969     parentObj.registerE = parentObj.registerA;
970   },
971   //LD H, B
972   //#0x60:
973   function (parentObj) {
974     parentObj.registersHL = (parentObj.registerB << 8) | (parentObj.registersHL & 0xFF);
975   },
976   //LD H, C
977   //#0x61:
978   function (parentObj) {
979     parentObj.registersHL = (parentObj.registerC << 8) | (parentObj.registersHL & 0xFF);
980   },
981   //LD H, D
982   //#0x62:
983   function (parentObj) {
984     parentObj.registersHL = (parentObj.registerD << 8) | (parentObj.registersHL & 0xFF);
985   },
986   //LD H, E
987   //#0x63:
988   function (parentObj) {
989     parentObj.registersHL = (parentObj.registerE << 8) | (parentObj.registersHL & 0xFF);
990   },
991   //LD H, H
992   //#0x64:
993   function (parentObj) {
994     //Do nothing...
995   },
996   //LD H, L
997   //#0x65:
998   function (parentObj) {
999     parentObj.registersHL = (parentObj.registersHL & 0xFF) * 0x101;
1000   },
1001   //LD H, (HL)
1002   //#0x66:
1003   function (parentObj) {
1004     parentObj.registersHL = (parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) << 8) | (parentObj.registersHL & 0xFF);
1005   },
1006   //LD H, A
1007   //#0x67:
1008   function (parentObj) {
1009     parentObj.registersHL = (parentObj.registerA << 8) | (parentObj.registersHL & 0xFF);
1010   },
1011   //LD L, B
1012   //#0x68:
1013   function (parentObj) {
1014     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | parentObj.registerB;
1015   },
1016   //LD L, C
1017   //#0x69:
1018   function (parentObj) {
1019     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | parentObj.registerC;
1020   },
1021   //LD L, D
1022   //#0x6A:
1023   function (parentObj) {
1024     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | parentObj.registerD;
1025   },
1026   //LD L, E
1027   //#0x6B:
1028   function (parentObj) {
1029     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | parentObj.registerE;
1030   },
1031   //LD L, H
1032   //#0x6C:
1033   function (parentObj) {
1034     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | (parentObj.registersHL >> 8);
1035   },
1036   //LD L, L
1037   //#0x6D:
1038   function (parentObj) {
1039     //Do nothing...
1040   },
1041   //LD L, (HL)
1042   //#0x6E:
1043   function (parentObj) {
1044     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1045   },
1046   //LD L, A
1047   //#0x6F:
1048   function (parentObj) {
1049     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | parentObj.registerA;
1050   },
1051   //LD (HL), B
1052   //#0x70:
1053   function (parentObj) {
1054     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registerB);
1055   },
1056   //LD (HL), C
1057   //#0x71:
1058   function (parentObj) {
1059     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registerC);
1060   },
1061   //LD (HL), D
1062   //#0x72:
1063   function (parentObj) {
1064     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registerD);
1065   },
1066   //LD (HL), E
1067   //#0x73:
1068   function (parentObj) {
1069     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registerE);
1070   },
1071   //LD (HL), H
1072   //#0x74:
1073   function (parentObj) {
1074     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registersHL >> 8);
1075   },
1076   //LD (HL), L
1077   //#0x75:
1078   function (parentObj) {
1079     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registersHL & 0xFF);
1080   },
1081   //HALT
1082   //#0x76:
1083   function (parentObj) {
1084     //See if there's already an IRQ match:
1085     if ((parentObj.interruptsEnabled & parentObj.interruptsRequested & 0x1F) > 0) {
1086       if (!parentObj.cGBC && !parentObj.usedBootROM) {
1087         //HALT bug in the DMG CPU model (Program Counter fails to increment for one instruction after HALT):
1088         parentObj.skipPCIncrement = true;
1089       }
1090       else {
1091         //CGB gets around the HALT PC bug by doubling the hidden NOP.
1092         parentObj.CPUTicks += 4;
1093       }
1094     }
1095     else {
1096       //CPU is stalled until the next IRQ match:
1097       parentObj.calculateHALTPeriod();
1098     }
1099   },
1100   //LD (HL), A
1101   //#0x77:
1102   function (parentObj) {
1103     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.registerA);
1104   },
1105   //LD A, B
1106   //#0x78:
1107   function (parentObj) {
1108     parentObj.registerA = parentObj.registerB;
1109   },
1110   //LD A, C
1111   //#0x79:
1112   function (parentObj) {
1113     parentObj.registerA = parentObj.registerC;
1114   },
1115   //LD A, D
1116   //#0x7A:
1117   function (parentObj) {
1118     parentObj.registerA = parentObj.registerD;
1119   },
1120   //LD A, E
1121   //#0x7B:
1122   function (parentObj) {
1123     parentObj.registerA = parentObj.registerE;
1124   },
1125   //LD A, H
1126   //#0x7C:
1127   function (parentObj) {
1128     parentObj.registerA = parentObj.registersHL >> 8;
1129   },
1130   //LD A, L
1131   //#0x7D:
1132   function (parentObj) {
1133     parentObj.registerA = parentObj.registersHL & 0xFF;
1134   },
1135   //LD, A, (HL)
1136   //#0x7E:
1137   function (parentObj) {
1138     parentObj.registerA = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1139   },
1140   //LD A, A
1141   //#0x7F:
1142   function (parentObj) {
1143     //Do Nothing...
1144   },
1145   //ADD A, B
1146   //#0x80:
1147   function (parentObj) {
1148     var dirtySum = parentObj.registerA + parentObj.registerB;
1149     parentObj.FHalfCarry = ((dirtySum & 0xF) < (parentObj.registerA & 0xF));
1150     parentObj.FCarry = (dirtySum > 0xFF);
1151     parentObj.registerA = dirtySum & 0xFF;
1152     parentObj.FZero = (parentObj.registerA == 0);
1153     parentObj.FSubtract = false;
1154   },
1155   //ADD A, C
1156   //#0x81:
1157   function (parentObj) {
1158     var dirtySum = parentObj.registerA + parentObj.registerC;
1159     parentObj.FHalfCarry = ((dirtySum & 0xF) < (parentObj.registerA & 0xF));
1160     parentObj.FCarry = (dirtySum > 0xFF);
1161     parentObj.registerA = dirtySum & 0xFF;
1162     parentObj.FZero = (parentObj.registerA == 0);
1163     parentObj.FSubtract = false;
1164   },
1165   //ADD A, D
1166   //#0x82:
1167   function (parentObj) {
1168     var dirtySum = parentObj.registerA + parentObj.registerD;
1169     parentObj.FHalfCarry = ((dirtySum & 0xF) < (parentObj.registerA & 0xF));
1170     parentObj.FCarry = (dirtySum > 0xFF);
1171     parentObj.registerA = dirtySum & 0xFF;
1172     parentObj.FZero = (parentObj.registerA == 0);
1173     parentObj.FSubtract = false;
1174   },
1175   //ADD A, E
1176   //#0x83:
1177   function (parentObj) {
1178     var dirtySum = parentObj.registerA + parentObj.registerE;
1179     parentObj.FHalfCarry = ((dirtySum & 0xF) < (parentObj.registerA & 0xF));
1180     parentObj.FCarry = (dirtySum > 0xFF);
1181     parentObj.registerA = dirtySum & 0xFF;
1182     parentObj.FZero = (parentObj.registerA == 0);
1183     parentObj.FSubtract = false;
1184   },
1185   //ADD A, H
1186   //#0x84:
1187   function (parentObj) {
1188     var dirtySum = parentObj.registerA + (parentObj.registersHL >> 8);
1189     parentObj.FHalfCarry = ((dirtySum & 0xF) < (parentObj.registerA & 0xF));
1190     parentObj.FCarry = (dirtySum > 0xFF);
1191     parentObj.registerA = dirtySum & 0xFF;
1192     parentObj.FZero = (parentObj.registerA == 0);
1193     parentObj.FSubtract = false;
1194   },
1195   //ADD A, L
1196   //#0x85:
1197   function (parentObj) {
1198     var dirtySum = parentObj.registerA + (parentObj.registersHL & 0xFF);
1199     parentObj.FHalfCarry = ((dirtySum & 0xF) < (parentObj.registerA & 0xF));
1200     parentObj.FCarry = (dirtySum > 0xFF);
1201     parentObj.registerA = dirtySum & 0xFF;
1202     parentObj.FZero = (parentObj.registerA == 0);
1203     parentObj.FSubtract = false;
1204   },
1205   //ADD A, (HL)
1206   //#0x86:
1207   function (parentObj) {
1208     var dirtySum = parentObj.registerA + parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1209     parentObj.FHalfCarry = ((dirtySum & 0xF) < (parentObj.registerA & 0xF));
1210     parentObj.FCarry = (dirtySum > 0xFF);
1211     parentObj.registerA = dirtySum & 0xFF;
1212     parentObj.FZero = (parentObj.registerA == 0);
1213     parentObj.FSubtract = false;
1214   },
1215   //ADD A, A
1216   //#0x87:
1217   function (parentObj) {
1218     parentObj.FHalfCarry = ((parentObj.registerA & 0x8) == 0x8);
1219     parentObj.FCarry = (parentObj.registerA > 0x7F);
1220     parentObj.registerA = (parentObj.registerA << 1) & 0xFF;
1221     parentObj.FZero = (parentObj.registerA == 0);
1222     parentObj.FSubtract = false;
1223   },
1224   //ADC A, B
1225   //#0x88:
1226   function (parentObj) {
1227     var dirtySum = parentObj.registerA + parentObj.registerB + ((parentObj.FCarry) ? 1 : 0);
1228     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) + (parentObj.registerB & 0xF) + ((parentObj.FCarry) ? 1 : 0) > 0xF);
1229     parentObj.FCarry = (dirtySum > 0xFF);
1230     parentObj.registerA = dirtySum & 0xFF;
1231     parentObj.FZero = (parentObj.registerA == 0);
1232     parentObj.FSubtract = false;
1233   },
1234   //ADC A, C
1235   //#0x89:
1236   function (parentObj) {
1237     var dirtySum = parentObj.registerA + parentObj.registerC + ((parentObj.FCarry) ? 1 : 0);
1238     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) + (parentObj.registerC & 0xF) + ((parentObj.FCarry) ? 1 : 0) > 0xF);
1239     parentObj.FCarry = (dirtySum > 0xFF);
1240     parentObj.registerA = dirtySum & 0xFF;
1241     parentObj.FZero = (parentObj.registerA == 0);
1242     parentObj.FSubtract = false;
1243   },
1244   //ADC A, D
1245   //#0x8A:
1246   function (parentObj) {
1247     var dirtySum = parentObj.registerA + parentObj.registerD + ((parentObj.FCarry) ? 1 : 0);
1248     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) + (parentObj.registerD & 0xF) + ((parentObj.FCarry) ? 1 : 0) > 0xF);
1249     parentObj.FCarry = (dirtySum > 0xFF);
1250     parentObj.registerA = dirtySum & 0xFF;
1251     parentObj.FZero = (parentObj.registerA == 0);
1252     parentObj.FSubtract = false;
1253   },
1254   //ADC A, E
1255   //#0x8B:
1256   function (parentObj) {
1257     var dirtySum = parentObj.registerA + parentObj.registerE + ((parentObj.FCarry) ? 1 : 0);
1258     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) + (parentObj.registerE & 0xF) + ((parentObj.FCarry) ? 1 : 0) > 0xF);
1259     parentObj.FCarry = (dirtySum > 0xFF);
1260     parentObj.registerA = dirtySum & 0xFF;
1261     parentObj.FZero = (parentObj.registerA == 0);
1262     parentObj.FSubtract = false;
1263   },
1264   //ADC A, H
1265   //#0x8C:
1266   function (parentObj) {
1267     var tempValue = (parentObj.registersHL >> 8);
1268     var dirtySum = parentObj.registerA + tempValue + ((parentObj.FCarry) ? 1 : 0);
1269     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) + (tempValue & 0xF) + ((parentObj.FCarry) ? 1 : 0) > 0xF);
1270     parentObj.FCarry = (dirtySum > 0xFF);
1271     parentObj.registerA = dirtySum & 0xFF;
1272     parentObj.FZero = (parentObj.registerA == 0);
1273     parentObj.FSubtract = false;
1274   },
1275   //ADC A, L
1276   //#0x8D:
1277   function (parentObj) {
1278     var tempValue = (parentObj.registersHL & 0xFF);
1279     var dirtySum = parentObj.registerA + tempValue + ((parentObj.FCarry) ? 1 : 0);
1280     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) + (tempValue & 0xF) + ((parentObj.FCarry) ? 1 : 0) > 0xF);
1281     parentObj.FCarry = (dirtySum > 0xFF);
1282     parentObj.registerA = dirtySum & 0xFF;
1283     parentObj.FZero = (parentObj.registerA == 0);
1284     parentObj.FSubtract = false;
1285   },
1286   //ADC A, (HL)
1287   //#0x8E:
1288   function (parentObj) {
1289     var tempValue = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1290     var dirtySum = parentObj.registerA + tempValue + ((parentObj.FCarry) ? 1 : 0);
1291     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) + (tempValue & 0xF) + ((parentObj.FCarry) ? 1 : 0) > 0xF);
1292     parentObj.FCarry = (dirtySum > 0xFF);
1293     parentObj.registerA = dirtySum & 0xFF;
1294     parentObj.FZero = (parentObj.registerA == 0);
1295     parentObj.FSubtract = false;
1296   },
1297   //ADC A, A
1298   //#0x8F:
1299   function (parentObj) {
1300     //shift left register A one bit for some ops here as an optimization:
1301     var dirtySum = (parentObj.registerA << 1) | ((parentObj.FCarry) ? 1 : 0);
1302     parentObj.FHalfCarry = ((((parentObj.registerA << 1) & 0x1E) | ((parentObj.FCarry) ? 1 : 0)) > 0xF);
1303     parentObj.FCarry = (dirtySum > 0xFF);
1304     parentObj.registerA = dirtySum & 0xFF;
1305     parentObj.FZero = (parentObj.registerA == 0);
1306     parentObj.FSubtract = false;
1307   },
1308   //SUB A, B
1309   //#0x90:
1310   function (parentObj) {
1311     var dirtySum = parentObj.registerA - parentObj.registerB;
1312     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) < (dirtySum & 0xF));
1313     parentObj.FCarry = (dirtySum < 0);
1314     parentObj.registerA = dirtySum & 0xFF;
1315     parentObj.FZero = (dirtySum == 0);
1316     parentObj.FSubtract = true;
1317   },
1318   //SUB A, C
1319   //#0x91:
1320   function (parentObj) {
1321     var dirtySum = parentObj.registerA - parentObj.registerC;
1322     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) < (dirtySum & 0xF));
1323     parentObj.FCarry = (dirtySum < 0);
1324     parentObj.registerA = dirtySum & 0xFF;
1325     parentObj.FZero = (dirtySum == 0);
1326     parentObj.FSubtract = true;
1327   },
1328   //SUB A, D
1329   //#0x92:
1330   function (parentObj) {
1331     var dirtySum = parentObj.registerA - parentObj.registerD;
1332     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) < (dirtySum & 0xF));
1333     parentObj.FCarry = (dirtySum < 0);
1334     parentObj.registerA = dirtySum & 0xFF;
1335     parentObj.FZero = (dirtySum == 0);
1336     parentObj.FSubtract = true;
1337   },
1338   //SUB A, E
1339   //#0x93:
1340   function (parentObj) {
1341     var dirtySum = parentObj.registerA - parentObj.registerE;
1342     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) < (dirtySum & 0xF));
1343     parentObj.FCarry = (dirtySum < 0);
1344     parentObj.registerA = dirtySum & 0xFF;
1345     parentObj.FZero = (dirtySum == 0);
1346     parentObj.FSubtract = true;
1347   },
1348   //SUB A, H
1349   //#0x94:
1350   function (parentObj) {
1351     var dirtySum = parentObj.registerA - (parentObj.registersHL >> 8);
1352     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) < (dirtySum & 0xF));
1353     parentObj.FCarry = (dirtySum < 0);
1354     parentObj.registerA = dirtySum & 0xFF;
1355     parentObj.FZero = (dirtySum == 0);
1356     parentObj.FSubtract = true;
1357   },
1358   //SUB A, L
1359   //#0x95:
1360   function (parentObj) {
1361     var dirtySum = parentObj.registerA - (parentObj.registersHL & 0xFF);
1362     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) < (dirtySum & 0xF));
1363     parentObj.FCarry = (dirtySum < 0);
1364     parentObj.registerA = dirtySum & 0xFF;
1365     parentObj.FZero = (dirtySum == 0);
1366     parentObj.FSubtract = true;
1367   },
1368   //SUB A, (HL)
1369   //#0x96:
1370   function (parentObj) {
1371     var dirtySum = parentObj.registerA - parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1372     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) < (dirtySum & 0xF));
1373     parentObj.FCarry = (dirtySum < 0);
1374     parentObj.registerA = dirtySum & 0xFF;
1375     parentObj.FZero = (dirtySum == 0);
1376     parentObj.FSubtract = true;
1377   },
1378   //SUB A, A
1379   //#0x97:
1380   function (parentObj) {
1381     //number - same number == 0
1382     parentObj.registerA = 0;
1383     parentObj.FHalfCarry = parentObj.FCarry = false;
1384     parentObj.FZero = parentObj.FSubtract = true;
1385   },
1386   //SBC A, B
1387   //#0x98:
1388   function (parentObj) {
1389     var dirtySum = parentObj.registerA - parentObj.registerB - ((parentObj.FCarry) ? 1 : 0);
1390     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) - (parentObj.registerB & 0xF) - ((parentObj.FCarry) ? 1 : 0) < 0);
1391     parentObj.FCarry = (dirtySum < 0);
1392     parentObj.registerA = dirtySum & 0xFF;
1393     parentObj.FZero = (parentObj.registerA == 0);
1394     parentObj.FSubtract = true;
1395   },
1396   //SBC A, C
1397   //#0x99:
1398   function (parentObj) {
1399     var dirtySum = parentObj.registerA - parentObj.registerC - ((parentObj.FCarry) ? 1 : 0);
1400     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) - (parentObj.registerC & 0xF) - ((parentObj.FCarry) ? 1 : 0) < 0);
1401     parentObj.FCarry = (dirtySum < 0);
1402     parentObj.registerA = dirtySum & 0xFF;
1403     parentObj.FZero = (parentObj.registerA == 0);
1404     parentObj.FSubtract = true;
1405   },
1406   //SBC A, D
1407   //#0x9A:
1408   function (parentObj) {
1409     var dirtySum = parentObj.registerA - parentObj.registerD - ((parentObj.FCarry) ? 1 : 0);
1410     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) - (parentObj.registerD & 0xF) - ((parentObj.FCarry) ? 1 : 0) < 0);
1411     parentObj.FCarry = (dirtySum < 0);
1412     parentObj.registerA = dirtySum & 0xFF;
1413     parentObj.FZero = (parentObj.registerA == 0);
1414     parentObj.FSubtract = true;
1415   },
1416   //SBC A, E
1417   //#0x9B:
1418   function (parentObj) {
1419     var dirtySum = parentObj.registerA - parentObj.registerE - ((parentObj.FCarry) ? 1 : 0);
1420     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) - (parentObj.registerE & 0xF) - ((parentObj.FCarry) ? 1 : 0) < 0);
1421     parentObj.FCarry = (dirtySum < 0);
1422     parentObj.registerA = dirtySum & 0xFF;
1423     parentObj.FZero = (parentObj.registerA == 0);
1424     parentObj.FSubtract = true;
1425   },
1426   //SBC A, H
1427   //#0x9C:
1428   function (parentObj) {
1429     var temp_var = parentObj.registersHL >> 8;
1430     var dirtySum = parentObj.registerA - temp_var - ((parentObj.FCarry) ? 1 : 0);
1431     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) - (temp_var & 0xF) - ((parentObj.FCarry) ? 1 : 0) < 0);
1432     parentObj.FCarry = (dirtySum < 0);
1433     parentObj.registerA = dirtySum & 0xFF;
1434     parentObj.FZero = (parentObj.registerA == 0);
1435     parentObj.FSubtract = true;
1436   },
1437   //SBC A, L
1438   //#0x9D:
1439   function (parentObj) {
1440     var dirtySum = parentObj.registerA - (parentObj.registersHL & 0xFF) - ((parentObj.FCarry) ? 1 : 0);
1441     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) - (parentObj.registersHL & 0xF) - ((parentObj.FCarry) ? 1 : 0) < 0);
1442     parentObj.FCarry = (dirtySum < 0);
1443     parentObj.registerA = dirtySum & 0xFF;
1444     parentObj.FZero = (parentObj.registerA == 0);
1445     parentObj.FSubtract = true;
1446   },
1447   //SBC A, (HL)
1448   //#0x9E:
1449   function (parentObj) {
1450     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1451     var dirtySum = parentObj.registerA - temp_var - ((parentObj.FCarry) ? 1 : 0);
1452     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) - (temp_var & 0xF) - ((parentObj.FCarry) ? 1 : 0) < 0);
1453     parentObj.FCarry = (dirtySum < 0);
1454     parentObj.registerA = dirtySum & 0xFF;
1455     parentObj.FZero = (parentObj.registerA == 0);
1456     parentObj.FSubtract = true;
1457   },
1458   //SBC A, A
1459   //#0x9F:
1460   function (parentObj) {
1461     //Optimized SBC A:
1462     if (parentObj.FCarry) {
1463       parentObj.FZero = false;
1464       parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = true;
1465       parentObj.registerA = 0xFF;
1466     }
1467     else {
1468       parentObj.FHalfCarry = parentObj.FCarry = false;
1469       parentObj.FSubtract = parentObj.FZero = true;
1470       parentObj.registerA = 0;
1471     }
1472   },
1473   //AND B
1474   //#0xA0:
1475   function (parentObj) {
1476     parentObj.registerA &= parentObj.registerB;
1477     parentObj.FZero = (parentObj.registerA == 0);
1478     parentObj.FHalfCarry = true;
1479     parentObj.FSubtract = parentObj.FCarry = false;
1480   },
1481   //AND C
1482   //#0xA1:
1483   function (parentObj) {
1484     parentObj.registerA &= parentObj.registerC;
1485     parentObj.FZero = (parentObj.registerA == 0);
1486     parentObj.FHalfCarry = true;
1487     parentObj.FSubtract = parentObj.FCarry = false;
1488   },
1489   //AND D
1490   //#0xA2:
1491   function (parentObj) {
1492     parentObj.registerA &= parentObj.registerD;
1493     parentObj.FZero = (parentObj.registerA == 0);
1494     parentObj.FHalfCarry = true;
1495     parentObj.FSubtract = parentObj.FCarry = false;
1496   },
1497   //AND E
1498   //#0xA3:
1499   function (parentObj) {
1500     parentObj.registerA &= parentObj.registerE;
1501     parentObj.FZero = (parentObj.registerA == 0);
1502     parentObj.FHalfCarry = true;
1503     parentObj.FSubtract = parentObj.FCarry = false;
1504   },
1505   //AND H
1506   //#0xA4:
1507   function (parentObj) {
1508     parentObj.registerA &= (parentObj.registersHL >> 8);
1509     parentObj.FZero = (parentObj.registerA == 0);
1510     parentObj.FHalfCarry = true;
1511     parentObj.FSubtract = parentObj.FCarry = false;
1512   },
1513   //AND L
1514   //#0xA5:
1515   function (parentObj) {
1516     parentObj.registerA &= parentObj.registersHL;
1517     parentObj.FZero = (parentObj.registerA == 0);
1518     parentObj.FHalfCarry = true;
1519     parentObj.FSubtract = parentObj.FCarry = false;
1520   },
1521   //AND (HL)
1522   //#0xA6:
1523   function (parentObj) {
1524     parentObj.registerA &= parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1525     parentObj.FZero = (parentObj.registerA == 0);
1526     parentObj.FHalfCarry = true;
1527     parentObj.FSubtract = parentObj.FCarry = false;
1528   },
1529   //AND A
1530   //#0xA7:
1531   function (parentObj) {
1532     //number & same number = same number
1533     parentObj.FZero = (parentObj.registerA == 0);
1534     parentObj.FHalfCarry = true;
1535     parentObj.FSubtract = parentObj.FCarry = false;
1536   },
1537   //XOR B
1538   //#0xA8:
1539   function (parentObj) {
1540     parentObj.registerA ^= parentObj.registerB;
1541     parentObj.FZero = (parentObj.registerA == 0);
1542     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
1543   },
1544   //XOR C
1545   //#0xA9:
1546   function (parentObj) {
1547     parentObj.registerA ^= parentObj.registerC;
1548     parentObj.FZero = (parentObj.registerA == 0);
1549     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
1550   },
1551   //XOR D
1552   //#0xAA:
1553   function (parentObj) {
1554     parentObj.registerA ^= parentObj.registerD;
1555     parentObj.FZero = (parentObj.registerA == 0);
1556     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
1557   },
1558   //XOR E
1559   //#0xAB:
1560   function (parentObj) {
1561     parentObj.registerA ^= parentObj.registerE;
1562     parentObj.FZero = (parentObj.registerA == 0);
1563     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
1564   },
1565   //XOR H
1566   //#0xAC:
1567   function (parentObj) {
1568     parentObj.registerA ^= (parentObj.registersHL >> 8);
1569     parentObj.FZero = (parentObj.registerA == 0);
1570     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
1571   },
1572   //XOR L
1573   //#0xAD:
1574   function (parentObj) {
1575     parentObj.registerA ^= (parentObj.registersHL & 0xFF);
1576     parentObj.FZero = (parentObj.registerA == 0);
1577     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
1578   },
1579   //XOR (HL)
1580   //#0xAE:
1581   function (parentObj) {
1582     parentObj.registerA ^= parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1583     parentObj.FZero = (parentObj.registerA == 0);
1584     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
1585   },
1586   //XOR A
1587   //#0xAF:
1588   function (parentObj) {
1589     //number ^ same number == 0
1590     parentObj.registerA = 0;
1591     parentObj.FZero = true;
1592     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
1593   },
1594   //OR B
1595   //#0xB0:
1596   function (parentObj) {
1597     parentObj.registerA |= parentObj.registerB;
1598     parentObj.FZero = (parentObj.registerA == 0);
1599     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
1600   },
1601   //OR C
1602   //#0xB1:
1603   function (parentObj) {
1604     parentObj.registerA |= parentObj.registerC;
1605     parentObj.FZero = (parentObj.registerA == 0);
1606     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
1607   },
1608   //OR D
1609   //#0xB2:
1610   function (parentObj) {
1611     parentObj.registerA |= parentObj.registerD;
1612     parentObj.FZero = (parentObj.registerA == 0);
1613     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
1614   },
1615   //OR E
1616   //#0xB3:
1617   function (parentObj) {
1618     parentObj.registerA |= parentObj.registerE;
1619     parentObj.FZero = (parentObj.registerA == 0);
1620     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
1621   },
1622   //OR H
1623   //#0xB4:
1624   function (parentObj) {
1625     parentObj.registerA |= (parentObj.registersHL >> 8);
1626     parentObj.FZero = (parentObj.registerA == 0);
1627     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
1628   },
1629   //OR L
1630   //#0xB5:
1631   function (parentObj) {
1632     parentObj.registerA |= (parentObj.registersHL & 0xFF);
1633     parentObj.FZero = (parentObj.registerA == 0);
1634     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
1635   },
1636   //OR (HL)
1637   //#0xB6:
1638   function (parentObj) {
1639     parentObj.registerA |= parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1640     parentObj.FZero = (parentObj.registerA == 0);
1641     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
1642   },
1643   //OR A
1644   //#0xB7:
1645   function (parentObj) {
1646     //number | same number == same number
1647     parentObj.FZero = (parentObj.registerA == 0);
1648     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
1649   },
1650   //CP B
1651   //#0xB8:
1652   function (parentObj) {
1653     var dirtySum = parentObj.registerA - parentObj.registerB;
1654     parentObj.FHalfCarry = ((dirtySum & 0xF) > (parentObj.registerA & 0xF));
1655     parentObj.FCarry = (dirtySum < 0);
1656     parentObj.FZero = (dirtySum == 0);
1657     parentObj.FSubtract = true;
1658   },
1659   //CP C
1660   //#0xB9:
1661   function (parentObj) {
1662     var dirtySum = parentObj.registerA - parentObj.registerC;
1663     parentObj.FHalfCarry = ((dirtySum & 0xF) > (parentObj.registerA & 0xF));
1664     parentObj.FCarry = (dirtySum < 0);
1665     parentObj.FZero = (dirtySum == 0);
1666     parentObj.FSubtract = true;
1667   },
1668   //CP D
1669   //#0xBA:
1670   function (parentObj) {
1671     var dirtySum = parentObj.registerA - parentObj.registerD;
1672     parentObj.FHalfCarry = ((dirtySum & 0xF) > (parentObj.registerA & 0xF));
1673     parentObj.FCarry = (dirtySum < 0);
1674     parentObj.FZero = (dirtySum == 0);
1675     parentObj.FSubtract = true;
1676   },
1677   //CP E
1678   //#0xBB:
1679   function (parentObj) {
1680     var dirtySum = parentObj.registerA - parentObj.registerE;
1681     parentObj.FHalfCarry = ((dirtySum & 0xF) > (parentObj.registerA & 0xF));
1682     parentObj.FCarry = (dirtySum < 0);
1683     parentObj.FZero = (dirtySum == 0);
1684     parentObj.FSubtract = true;
1685   },
1686   //CP H
1687   //#0xBC:
1688   function (parentObj) {
1689     var dirtySum = parentObj.registerA - (parentObj.registersHL >> 8);
1690     parentObj.FHalfCarry = ((dirtySum & 0xF) > (parentObj.registerA & 0xF));
1691     parentObj.FCarry = (dirtySum < 0);
1692     parentObj.FZero = (dirtySum == 0);
1693     parentObj.FSubtract = true;
1694   },
1695   //CP L
1696   //#0xBD:
1697   function (parentObj) {
1698     var dirtySum = parentObj.registerA - (parentObj.registersHL & 0xFF);
1699     parentObj.FHalfCarry = ((dirtySum & 0xF) > (parentObj.registerA & 0xF));
1700     parentObj.FCarry = (dirtySum < 0);
1701     parentObj.FZero = (dirtySum == 0);
1702     parentObj.FSubtract = true;
1703   },
1704   //CP (HL)
1705   //#0xBE:
1706   function (parentObj) {
1707     var dirtySum = parentObj.registerA - parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
1708     parentObj.FHalfCarry = ((dirtySum & 0xF) > (parentObj.registerA & 0xF));
1709     parentObj.FCarry = (dirtySum < 0);
1710     parentObj.FZero = (dirtySum == 0);
1711     parentObj.FSubtract = true;
1712   },
1713   //CP A
1714   //#0xBF:
1715   function (parentObj) {
1716     parentObj.FHalfCarry = parentObj.FCarry = false;
1717     parentObj.FZero = parentObj.FSubtract = true;
1718   },
1719   //RET !FZ
1720   //#0xC0:
1721   function (parentObj) {
1722     if (!parentObj.FZero) {
1723       parentObj.programCounter = (parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
1724       parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
1725       parentObj.CPUTicks += 12;
1726     }
1727   },
1728   //POP BC
1729   //#0xC1:
1730   function (parentObj) {
1731     parentObj.registerC = parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
1732     parentObj.registerB = parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF);
1733     parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
1734   },
1735   //JP !FZ, nn
1736   //#0xC2:
1737   function (parentObj) {
1738     if (!parentObj.FZero) {
1739       parentObj.programCounter = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1740       parentObj.CPUTicks += 4;
1741     }
1742     else {
1743       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1744     }
1745   },
1746   //JP nn
1747   //#0xC3:
1748   function (parentObj) {
1749     parentObj.programCounter = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1750   },
1751   //CALL !FZ, nn
1752   //#0xC4:
1753   function (parentObj) {
1754     if (!parentObj.FZero) {
1755       var temp_pc = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1756       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1757       parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1758       parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
1759       parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1760       parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
1761       parentObj.programCounter = temp_pc;
1762       parentObj.CPUTicks += 12;
1763     }
1764     else {
1765       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1766     }
1767   },
1768   //PUSH BC
1769   //#0xC5:
1770   function (parentObj) {
1771     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1772     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.registerB);
1773     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1774     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.registerC);
1775   },
1776   //ADD, n
1777   //#0xC6:
1778   function (parentObj) {
1779     var dirtySum = parentObj.registerA + parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1780     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
1781     parentObj.FHalfCarry = ((dirtySum & 0xF) < (parentObj.registerA & 0xF));
1782     parentObj.FCarry = (dirtySum > 0xFF);
1783     parentObj.registerA = dirtySum & 0xFF;
1784     parentObj.FZero = (parentObj.registerA == 0);
1785     parentObj.FSubtract = false;
1786   },
1787   //RST 0
1788   //#0xC7:
1789   function (parentObj) {
1790     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1791     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
1792     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1793     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
1794     parentObj.programCounter = 0;
1795   },
1796   //RET FZ
1797   //#0xC8:
1798   function (parentObj) {
1799     if (parentObj.FZero) {
1800       parentObj.programCounter = (parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
1801       parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
1802       parentObj.CPUTicks += 12;
1803     }
1804   },
1805   //RET
1806   //#0xC9:
1807   function (parentObj) {
1808     parentObj.programCounter =  (parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
1809     parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
1810   },
1811   //JP FZ, nn
1812   //#0xCA:
1813   function (parentObj) {
1814     if (parentObj.FZero) {
1815       parentObj.programCounter = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1816       parentObj.CPUTicks += 4;
1817     }
1818     else {
1819       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1820     }
1821   },
1822   //Secondary OP Code Set:
1823   //#0xCB:
1824   function (parentObj) {
1825     var opcode = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1826     //Increment the program counter to the next instruction:
1827     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
1828     //Get how many CPU cycles the current 0xCBXX op code counts for:
1829     parentObj.CPUTicks += parentObj.SecondaryTICKTable[opcode];
1830     //Execute secondary OP codes for the 0xCB OP code call.
1831     parentObj.CBOPCODE[opcode](parentObj);
1832   },
1833   //CALL FZ, nn
1834   //#0xCC:
1835   function (parentObj) {
1836     if (parentObj.FZero) {
1837       var temp_pc = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1838       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1839       parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1840       parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
1841       parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1842       parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
1843       parentObj.programCounter = temp_pc;
1844       parentObj.CPUTicks += 12;
1845     }
1846     else {
1847       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1848     }
1849   },
1850   //CALL nn
1851   //#0xCD:
1852   function (parentObj) {
1853     var temp_pc = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1854     parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1855     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1856     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
1857     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1858     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
1859     parentObj.programCounter = temp_pc;
1860   },
1861   //ADC A, n
1862   //#0xCE:
1863   function (parentObj) {
1864     var tempValue = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1865     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
1866     var dirtySum = parentObj.registerA + tempValue + ((parentObj.FCarry) ? 1 : 0);
1867     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) + (tempValue & 0xF) + ((parentObj.FCarry) ? 1 : 0) > 0xF);
1868     parentObj.FCarry = (dirtySum > 0xFF);
1869     parentObj.registerA = dirtySum & 0xFF;
1870     parentObj.FZero = (parentObj.registerA == 0);
1871     parentObj.FSubtract = false;
1872   },
1873   //RST 0x8
1874   //#0xCF:
1875   function (parentObj) {
1876     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1877     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
1878     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1879     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
1880     parentObj.programCounter = 0x8;
1881   },
1882   //RET !FC
1883   //#0xD0:
1884   function (parentObj) {
1885     if (!parentObj.FCarry) {
1886       parentObj.programCounter = (parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
1887       parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
1888       parentObj.CPUTicks += 12;
1889     }
1890   },
1891   //POP DE
1892   //#0xD1:
1893   function (parentObj) {
1894     parentObj.registerE = parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
1895     parentObj.registerD = parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF);
1896     parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
1897   },
1898   //JP !FC, nn
1899   //#0xD2:
1900   function (parentObj) {
1901     if (!parentObj.FCarry) {
1902       parentObj.programCounter = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1903       parentObj.CPUTicks += 4;
1904     }
1905     else {
1906       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1907     }
1908   },
1909   //0xD3 - Illegal
1910   //#0xD3:
1911   function (parentObj) {
1912     cout("Illegal op code 0xD3 called, pausing emulation.", 2);
1913     pause();
1914   },
1915   //CALL !FC, nn
1916   //#0xD4:
1917   function (parentObj) {
1918     if (!parentObj.FCarry) {
1919       var temp_pc = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1920       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1921       parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1922       parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
1923       parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1924       parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
1925       parentObj.programCounter = temp_pc;
1926       parentObj.CPUTicks += 12;
1927     }
1928     else {
1929       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1930     }
1931   },
1932   //PUSH DE
1933   //#0xD5:
1934   function (parentObj) {
1935     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1936     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.registerD);
1937     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1938     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.registerE);
1939   },
1940   //SUB A, n
1941   //#0xD6:
1942   function (parentObj) {
1943     var dirtySum = parentObj.registerA - parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1944     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
1945     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) < (dirtySum & 0xF));
1946     parentObj.FCarry = (dirtySum < 0);
1947     parentObj.registerA = dirtySum & 0xFF;
1948     parentObj.FZero = (dirtySum == 0);
1949     parentObj.FSubtract = true;
1950   },
1951   //RST 0x10
1952   //#0xD7:
1953   function (parentObj) {
1954     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1955     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
1956     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
1957     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
1958     parentObj.programCounter = 0x10;
1959   },
1960   //RET FC
1961   //#0xD8:
1962   function (parentObj) {
1963     if (parentObj.FCarry) {
1964       parentObj.programCounter = (parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
1965       parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
1966       parentObj.CPUTicks += 12;
1967     }
1968   },
1969   //RETI
1970   //#0xD9:
1971   function (parentObj) {
1972     parentObj.programCounter = (parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
1973     parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
1974     //Immediate for HALT:
1975     parentObj.IRQEnableDelay = (parentObj.IRQEnableDelay == 2 || parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) == 0x76) ? 1 : 2;
1976   },
1977   //JP FC, nn
1978   //#0xDA:
1979   function (parentObj) {
1980     if (parentObj.FCarry) {
1981       parentObj.programCounter = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1982       parentObj.CPUTicks += 4;
1983     }
1984     else {
1985       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
1986     }
1987   },
1988   //0xDB - Illegal
1989   //#0xDB:
1990   function (parentObj) {
1991     cout("Illegal op code 0xDB called, pausing emulation.", 2);
1992     pause();
1993   },
1994   //CALL FC, nn
1995   //#0xDC:
1996   function (parentObj) {
1997     if (parentObj.FCarry) {
1998       var temp_pc = (parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
1999       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
2000       parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2001       parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
2002       parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2003       parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
2004       parentObj.programCounter = temp_pc;
2005       parentObj.CPUTicks += 12;
2006     }
2007     else {
2008       parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
2009     }
2010   },
2011   //0xDD - Illegal
2012   //#0xDD:
2013   function (parentObj) {
2014     cout("Illegal op code 0xDD called, pausing emulation.", 2);
2015     pause();
2016   },
2017   //SBC A, n
2018   //#0xDE:
2019   function (parentObj) {
2020     var temp_var = parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
2021     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2022     var dirtySum = parentObj.registerA - temp_var - ((parentObj.FCarry) ? 1 : 0);
2023     parentObj.FHalfCarry = ((parentObj.registerA & 0xF) - (temp_var & 0xF) - ((parentObj.FCarry) ? 1 : 0) < 0);
2024     parentObj.FCarry = (dirtySum < 0);
2025     parentObj.registerA = dirtySum & 0xFF;
2026     parentObj.FZero = (parentObj.registerA == 0);
2027     parentObj.FSubtract = true;
2028   },
2029   //RST 0x18
2030   //#0xDF:
2031   function (parentObj) {
2032     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2033     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
2034     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2035     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
2036     parentObj.programCounter = 0x18;
2037   },
2038   //LDH (n), A
2039   //#0xE0:
2040   function (parentObj) {
2041     parentObj.memoryHighWrite(parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter), parentObj.registerA);
2042     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2043   },
2044   //POP HL
2045   //#0xE1:
2046   function (parentObj) {
2047     parentObj.registersHL = (parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
2048     parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
2049   },
2050   //LD (0xFF00 + C), A
2051   //#0xE2:
2052   function (parentObj) {
2053     parentObj.memoryHighWriter[parentObj.registerC](parentObj, parentObj.registerC, parentObj.registerA);
2054   },
2055   //0xE3 - Illegal
2056   //#0xE3:
2057   function (parentObj) {
2058     cout("Illegal op code 0xE3 called, pausing emulation.", 2);
2059     pause();
2060   },
2061   //0xE4 - Illegal
2062   //#0xE4:
2063   function (parentObj) {
2064     cout("Illegal op code 0xE4 called, pausing emulation.", 2);
2065     pause();
2066   },
2067   //PUSH HL
2068   //#0xE5:
2069   function (parentObj) {
2070     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2071     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.registersHL >> 8);
2072     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2073     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.registersHL & 0xFF);
2074   },
2075   //AND n
2076   //#0xE6:
2077   function (parentObj) {
2078     parentObj.registerA &= parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
2079     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2080     parentObj.FZero = (parentObj.registerA == 0);
2081     parentObj.FHalfCarry = true;
2082     parentObj.FSubtract = parentObj.FCarry = false;
2083   },
2084   //RST 0x20
2085   //#0xE7:
2086   function (parentObj) {
2087     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2088     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
2089     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2090     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
2091     parentObj.programCounter = 0x20;
2092   },
2093   //ADD SP, n
2094   //#0xE8:
2095   function (parentObj) {
2096     var temp_value2 = (parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) << 24) >> 24;
2097     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2098     var temp_value = (parentObj.stackPointer + temp_value2) & 0xFFFF;
2099     temp_value2 = parentObj.stackPointer ^ temp_value2 ^ temp_value;
2100     parentObj.stackPointer = temp_value;
2101     parentObj.FCarry = ((temp_value2 & 0x100) == 0x100);
2102     parentObj.FHalfCarry = ((temp_value2 & 0x10) == 0x10);
2103     parentObj.FZero = parentObj.FSubtract = false;
2104   },
2105   //JP, (HL)
2106   //#0xE9:
2107   function (parentObj) {
2108     parentObj.programCounter = parentObj.registersHL;
2109   },
2110   //LD n, A
2111   //#0xEA:
2112   function (parentObj) {
2113     parentObj.memoryWrite((parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter), parentObj.registerA);
2114     parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
2115   },
2116   //0xEB - Illegal
2117   //#0xEB:
2118   function (parentObj) {
2119     cout("Illegal op code 0xEB called, pausing emulation.", 2);
2120     pause();
2121   },
2122   //0xEC - Illegal
2123   //#0xEC:
2124   function (parentObj) {
2125     cout("Illegal op code 0xEC called, pausing emulation.", 2);
2126     pause();
2127   },
2128   //0xED - Illegal
2129   //#0xED:
2130   function (parentObj) {
2131     cout("Illegal op code 0xED called, pausing emulation.", 2);
2132     pause();
2133   },
2134   //XOR n
2135   //#0xEE:
2136   function (parentObj) {
2137     parentObj.registerA ^= parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
2138     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2139     parentObj.FZero = (parentObj.registerA == 0);
2140     parentObj.FSubtract = parentObj.FHalfCarry = parentObj.FCarry = false;
2141   },
2142   //RST 0x28
2143   //#0xEF:
2144   function (parentObj) {
2145     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2146     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
2147     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2148     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
2149     parentObj.programCounter = 0x28;
2150   },
2151   //LDH A, (n)
2152   //#0xF0:
2153   function (parentObj) {
2154     parentObj.registerA = parentObj.memoryHighRead(parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter));
2155     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2156   },
2157   //POP AF
2158   //#0xF1:
2159   function (parentObj) {
2160     var temp_var = parentObj.memoryReader[parentObj.stackPointer](parentObj, parentObj.stackPointer);
2161     parentObj.FZero = (temp_var > 0x7F);
2162     parentObj.FSubtract = ((temp_var & 0x40) == 0x40);
2163     parentObj.FHalfCarry = ((temp_var & 0x20) == 0x20);
2164     parentObj.FCarry = ((temp_var & 0x10) == 0x10);
2165     parentObj.registerA = parentObj.memoryRead((parentObj.stackPointer + 1) & 0xFFFF);
2166     parentObj.stackPointer = (parentObj.stackPointer + 2) & 0xFFFF;
2167   },
2168   //LD A, (0xFF00 + C)
2169   //#0xF2:
2170   function (parentObj) {
2171     parentObj.registerA = parentObj.memoryHighReader[parentObj.registerC](parentObj, parentObj.registerC);
2172   },
2173   //DI
2174   //#0xF3:
2175   function (parentObj) {
2176     parentObj.IME = false;
2177     parentObj.IRQEnableDelay = 0;
2178   },
2179   //0xF4 - Illegal
2180   //#0xF4:
2181   function (parentObj) {
2182     cout("Illegal op code 0xF4 called, pausing emulation.", 2);
2183     pause();
2184   },
2185   //PUSH AF
2186   //#0xF5:
2187   function (parentObj) {
2188     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2189     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.registerA);
2190     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2191     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, ((parentObj.FZero) ? 0x80 : 0) | ((parentObj.FSubtract) ? 0x40 : 0) | ((parentObj.FHalfCarry) ? 0x20 : 0) | ((parentObj.FCarry) ? 0x10 : 0));
2192   },
2193   //OR n
2194   //#0xF6:
2195   function (parentObj) {
2196     parentObj.registerA |= parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
2197     parentObj.FZero = (parentObj.registerA == 0);
2198     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2199     parentObj.FSubtract = parentObj.FCarry = parentObj.FHalfCarry = false;
2200   },
2201   //RST 0x30
2202   //#0xF7:
2203   function (parentObj) {
2204     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2205     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
2206     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2207     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
2208     parentObj.programCounter = 0x30;
2209   },
2210   //LDHL SP, n
2211   //#0xF8:
2212   function (parentObj) {
2213     var temp_var = (parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) << 24) >> 24;
2214     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2215     parentObj.registersHL = (parentObj.stackPointer + temp_var) & 0xFFFF;
2216     temp_var = parentObj.stackPointer ^ temp_var ^ parentObj.registersHL;
2217     parentObj.FCarry = ((temp_var & 0x100) == 0x100);
2218     parentObj.FHalfCarry = ((temp_var & 0x10) == 0x10);
2219     parentObj.FZero = parentObj.FSubtract = false;
2220   },
2221   //LD SP, HL
2222   //#0xF9:
2223   function (parentObj) {
2224     parentObj.stackPointer = parentObj.registersHL;
2225   },
2226   //LD A, (nn)
2227   //#0xFA:
2228   function (parentObj) {
2229     parentObj.registerA = parentObj.memoryRead((parentObj.memoryRead((parentObj.programCounter + 1) & 0xFFFF) << 8) | parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter));
2230     parentObj.programCounter = (parentObj.programCounter + 2) & 0xFFFF;
2231   },
2232   //EI
2233   //#0xFB:
2234   function (parentObj) {
2235     //Immediate for HALT:
2236     parentObj.IRQEnableDelay = (parentObj.IRQEnableDelay == 2 || parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter) == 0x76) ? 1 : 2;
2237   },
2238   //0xFC - Illegal
2239   //#0xFC:
2240   function (parentObj) {
2241     cout("Illegal op code 0xFC called, pausing emulation.", 2);
2242     pause();
2243   },
2244   //0xFD - Illegal
2245   //#0xFD:
2246   function (parentObj) {
2247     cout("Illegal op code 0xFD called, pausing emulation.", 2);
2248     pause();
2249   },
2250   //CP n
2251   //#0xFE:
2252   function (parentObj) {
2253     var dirtySum = parentObj.registerA - parentObj.memoryReader[parentObj.programCounter](parentObj, parentObj.programCounter);
2254     parentObj.programCounter = (parentObj.programCounter + 1) & 0xFFFF;
2255     parentObj.FHalfCarry = ((dirtySum & 0xF) > (parentObj.registerA & 0xF));
2256     parentObj.FCarry = (dirtySum < 0);
2257     parentObj.FZero = (dirtySum == 0);
2258     parentObj.FSubtract = true;
2259   },
2260   //RST 0x38
2261   //#0xFF:
2262   function (parentObj) {
2263     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2264     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter >> 8);
2265     parentObj.stackPointer = (parentObj.stackPointer - 1) & 0xFFFF;
2266     parentObj.memoryWriter[parentObj.stackPointer](parentObj, parentObj.stackPointer, parentObj.programCounter & 0xFF);
2267     parentObj.programCounter = 0x38;
2268   }
2269 ];
2270 GameBoyCore.prototype.CBOPCODE = [
2271   //RLC B
2272   //#0x00:
2273   function (parentObj) {
2274     parentObj.FCarry = (parentObj.registerB > 0x7F);
2275     parentObj.registerB = ((parentObj.registerB << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2276     parentObj.FHalfCarry = parentObj.FSubtract = false;
2277     parentObj.FZero = (parentObj.registerB == 0);
2278   }
2279   //RLC C
2280   //#0x01:
2281   ,function (parentObj) {
2282     parentObj.FCarry = (parentObj.registerC > 0x7F);
2283     parentObj.registerC = ((parentObj.registerC << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2284     parentObj.FHalfCarry = parentObj.FSubtract = false;
2285     parentObj.FZero = (parentObj.registerC == 0);
2286   }
2287   //RLC D
2288   //#0x02:
2289   ,function (parentObj) {
2290     parentObj.FCarry = (parentObj.registerD > 0x7F);
2291     parentObj.registerD = ((parentObj.registerD << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2292     parentObj.FHalfCarry = parentObj.FSubtract = false;
2293     parentObj.FZero = (parentObj.registerD == 0);
2294   }
2295   //RLC E
2296   //#0x03:
2297   ,function (parentObj) {
2298     parentObj.FCarry = (parentObj.registerE > 0x7F);
2299     parentObj.registerE = ((parentObj.registerE << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2300     parentObj.FHalfCarry = parentObj.FSubtract = false;
2301     parentObj.FZero = (parentObj.registerE == 0);
2302   }
2303   //RLC H
2304   //#0x04:
2305   ,function (parentObj) {
2306     parentObj.FCarry = (parentObj.registersHL > 0x7FFF);
2307     parentObj.registersHL = ((parentObj.registersHL << 1) & 0xFE00) | ((parentObj.FCarry) ? 0x100 : 0) | (parentObj.registersHL & 0xFF);
2308     parentObj.FHalfCarry = parentObj.FSubtract = false;
2309     parentObj.FZero = (parentObj.registersHL < 0x100);
2310   }
2311   //RLC L
2312   //#0x05:
2313   ,function (parentObj) {
2314     parentObj.FCarry = ((parentObj.registersHL & 0x80) == 0x80);
2315     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | ((parentObj.registersHL << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2316     parentObj.FHalfCarry = parentObj.FSubtract = false;
2317     parentObj.FZero = ((parentObj.registersHL & 0xFF) == 0);
2318   }
2319   //RLC (HL)
2320   //#0x06:
2321   ,function (parentObj) {
2322     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
2323     parentObj.FCarry = (temp_var > 0x7F);
2324     temp_var = ((temp_var << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2325     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
2326     parentObj.FHalfCarry = parentObj.FSubtract = false;
2327     parentObj.FZero = (temp_var == 0);
2328   }
2329   //RLC A
2330   //#0x07:
2331   ,function (parentObj) {
2332     parentObj.FCarry = (parentObj.registerA > 0x7F);
2333     parentObj.registerA = ((parentObj.registerA << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2334     parentObj.FHalfCarry = parentObj.FSubtract = false;
2335     parentObj.FZero = (parentObj.registerA == 0);
2336   }
2337   //RRC B
2338   //#0x08:
2339   ,function (parentObj) {
2340     parentObj.FCarry = ((parentObj.registerB & 0x01) == 0x01);
2341     parentObj.registerB = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerB >> 1);
2342     parentObj.FHalfCarry = parentObj.FSubtract = false;
2343     parentObj.FZero = (parentObj.registerB == 0);
2344   }
2345   //RRC C
2346   //#0x09:
2347   ,function (parentObj) {
2348     parentObj.FCarry = ((parentObj.registerC & 0x01) == 0x01);
2349     parentObj.registerC = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerC >> 1);
2350     parentObj.FHalfCarry = parentObj.FSubtract = false;
2351     parentObj.FZero = (parentObj.registerC == 0);
2352   }
2353   //RRC D
2354   //#0x0A:
2355   ,function (parentObj) {
2356     parentObj.FCarry = ((parentObj.registerD & 0x01) == 0x01);
2357     parentObj.registerD = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerD >> 1);
2358     parentObj.FHalfCarry = parentObj.FSubtract = false;
2359     parentObj.FZero = (parentObj.registerD == 0);
2360   }
2361   //RRC E
2362   //#0x0B:
2363   ,function (parentObj) {
2364     parentObj.FCarry = ((parentObj.registerE & 0x01) == 0x01);
2365     parentObj.registerE = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerE >> 1);
2366     parentObj.FHalfCarry = parentObj.FSubtract = false;
2367     parentObj.FZero = (parentObj.registerE == 0);
2368   }
2369   //RRC H
2370   //#0x0C:
2371   ,function (parentObj) {
2372     parentObj.FCarry = ((parentObj.registersHL & 0x0100) == 0x0100);
2373     parentObj.registersHL = ((parentObj.FCarry) ? 0x8000 : 0) | ((parentObj.registersHL >> 1) & 0xFF00) | (parentObj.registersHL & 0xFF);
2374     parentObj.FHalfCarry = parentObj.FSubtract = false;
2375     parentObj.FZero = (parentObj.registersHL < 0x100);
2376   }
2377   //RRC L
2378   //#0x0D:
2379   ,function (parentObj) {
2380     parentObj.FCarry = ((parentObj.registersHL & 0x01) == 0x01);
2381     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | ((parentObj.FCarry) ? 0x80 : 0) | ((parentObj.registersHL & 0xFF) >> 1);
2382     parentObj.FHalfCarry = parentObj.FSubtract = false;
2383     parentObj.FZero = ((parentObj.registersHL & 0xFF) == 0);
2384   }
2385   //RRC (HL)
2386   //#0x0E:
2387   ,function (parentObj) {
2388     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
2389     parentObj.FCarry = ((temp_var & 0x01) == 0x01);
2390     temp_var = ((parentObj.FCarry) ? 0x80 : 0) | (temp_var >> 1);
2391     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
2392     parentObj.FHalfCarry = parentObj.FSubtract = false;
2393     parentObj.FZero = (temp_var == 0);
2394   }
2395   //RRC A
2396   //#0x0F:
2397   ,function (parentObj) {
2398     parentObj.FCarry = ((parentObj.registerA & 0x01) == 0x01);
2399     parentObj.registerA = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerA >> 1);
2400     parentObj.FHalfCarry = parentObj.FSubtract = false;
2401     parentObj.FZero = (parentObj.registerA == 0);
2402   }
2403   //RL B
2404   //#0x10:
2405   ,function (parentObj) {
2406     var newFCarry = (parentObj.registerB > 0x7F);
2407     parentObj.registerB = ((parentObj.registerB << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2408     parentObj.FCarry = newFCarry;
2409     parentObj.FHalfCarry = parentObj.FSubtract = false;
2410     parentObj.FZero = (parentObj.registerB == 0);
2411   }
2412   //RL C
2413   //#0x11:
2414   ,function (parentObj) {
2415     var newFCarry = (parentObj.registerC > 0x7F);
2416     parentObj.registerC = ((parentObj.registerC << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2417     parentObj.FCarry = newFCarry;
2418     parentObj.FHalfCarry = parentObj.FSubtract = false;
2419     parentObj.FZero = (parentObj.registerC == 0);
2420   }
2421   //RL D
2422   //#0x12:
2423   ,function (parentObj) {
2424     var newFCarry = (parentObj.registerD > 0x7F);
2425     parentObj.registerD = ((parentObj.registerD << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2426     parentObj.FCarry = newFCarry;
2427     parentObj.FHalfCarry = parentObj.FSubtract = false;
2428     parentObj.FZero = (parentObj.registerD == 0);
2429   }
2430   //RL E
2431   //#0x13:
2432   ,function (parentObj) {
2433     var newFCarry = (parentObj.registerE > 0x7F);
2434     parentObj.registerE = ((parentObj.registerE << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2435     parentObj.FCarry = newFCarry;
2436     parentObj.FHalfCarry = parentObj.FSubtract = false;
2437     parentObj.FZero = (parentObj.registerE == 0);
2438   }
2439   //RL H
2440   //#0x14:
2441   ,function (parentObj) {
2442     var newFCarry = (parentObj.registersHL > 0x7FFF);
2443     parentObj.registersHL = ((parentObj.registersHL << 1) & 0xFE00) | ((parentObj.FCarry) ? 0x100 : 0) | (parentObj.registersHL & 0xFF);
2444     parentObj.FCarry = newFCarry;
2445     parentObj.FHalfCarry = parentObj.FSubtract = false;
2446     parentObj.FZero = (parentObj.registersHL < 0x100);
2447   }
2448   //RL L
2449   //#0x15:
2450   ,function (parentObj) {
2451     var newFCarry = ((parentObj.registersHL & 0x80) == 0x80);
2452     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | ((parentObj.registersHL << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2453     parentObj.FCarry = newFCarry;
2454     parentObj.FHalfCarry = parentObj.FSubtract = false;
2455     parentObj.FZero = ((parentObj.registersHL & 0xFF) == 0);
2456   }
2457   //RL (HL)
2458   //#0x16:
2459   ,function (parentObj) {
2460     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
2461     var newFCarry = (temp_var > 0x7F);
2462     temp_var = ((temp_var << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2463     parentObj.FCarry = newFCarry;
2464     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
2465     parentObj.FHalfCarry = parentObj.FSubtract = false;
2466     parentObj.FZero = (temp_var == 0);
2467   }
2468   //RL A
2469   //#0x17:
2470   ,function (parentObj) {
2471     var newFCarry = (parentObj.registerA > 0x7F);
2472     parentObj.registerA = ((parentObj.registerA << 1) & 0xFF) | ((parentObj.FCarry) ? 1 : 0);
2473     parentObj.FCarry = newFCarry;
2474     parentObj.FHalfCarry = parentObj.FSubtract = false;
2475     parentObj.FZero = (parentObj.registerA == 0);
2476   }
2477   //RR B
2478   //#0x18:
2479   ,function (parentObj) {
2480     var newFCarry = ((parentObj.registerB & 0x01) == 0x01);
2481     parentObj.registerB = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerB >> 1);
2482     parentObj.FCarry = newFCarry;
2483     parentObj.FHalfCarry = parentObj.FSubtract = false;
2484     parentObj.FZero = (parentObj.registerB == 0);
2485   }
2486   //RR C
2487   //#0x19:
2488   ,function (parentObj) {
2489     var newFCarry = ((parentObj.registerC & 0x01) == 0x01);
2490     parentObj.registerC = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerC >> 1);
2491     parentObj.FCarry = newFCarry;
2492     parentObj.FHalfCarry = parentObj.FSubtract = false;
2493     parentObj.FZero = (parentObj.registerC == 0);
2494   }
2495   //RR D
2496   //#0x1A:
2497   ,function (parentObj) {
2498     var newFCarry = ((parentObj.registerD & 0x01) == 0x01);
2499     parentObj.registerD = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerD >> 1);
2500     parentObj.FCarry = newFCarry;
2501     parentObj.FHalfCarry = parentObj.FSubtract = false;
2502     parentObj.FZero = (parentObj.registerD == 0);
2503   }
2504   //RR E
2505   //#0x1B:
2506   ,function (parentObj) {
2507     var newFCarry = ((parentObj.registerE & 0x01) == 0x01);
2508     parentObj.registerE = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerE >> 1);
2509     parentObj.FCarry = newFCarry;
2510     parentObj.FHalfCarry = parentObj.FSubtract = false;
2511     parentObj.FZero = (parentObj.registerE == 0);
2512   }
2513   //RR H
2514   //#0x1C:
2515   ,function (parentObj) {
2516     var newFCarry = ((parentObj.registersHL & 0x0100) == 0x0100);
2517     parentObj.registersHL = ((parentObj.FCarry) ? 0x8000 : 0) | ((parentObj.registersHL >> 1) & 0xFF00) | (parentObj.registersHL & 0xFF);
2518     parentObj.FCarry = newFCarry;
2519     parentObj.FHalfCarry = parentObj.FSubtract = false;
2520     parentObj.FZero = (parentObj.registersHL < 0x100);
2521   }
2522   //RR L
2523   //#0x1D:
2524   ,function (parentObj) {
2525     var newFCarry = ((parentObj.registersHL & 0x01) == 0x01);
2526     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | ((parentObj.FCarry) ? 0x80 : 0) | ((parentObj.registersHL & 0xFF) >> 1);
2527     parentObj.FCarry = newFCarry;
2528     parentObj.FHalfCarry = parentObj.FSubtract = false;
2529     parentObj.FZero = ((parentObj.registersHL & 0xFF) == 0);
2530   }
2531   //RR (HL)
2532   //#0x1E:
2533   ,function (parentObj) {
2534     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
2535     var newFCarry = ((temp_var & 0x01) == 0x01);
2536     temp_var = ((parentObj.FCarry) ? 0x80 : 0) | (temp_var >> 1);
2537     parentObj.FCarry = newFCarry;
2538     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
2539     parentObj.FHalfCarry = parentObj.FSubtract = false;
2540     parentObj.FZero = (temp_var == 0);
2541   }
2542   //RR A
2543   //#0x1F:
2544   ,function (parentObj) {
2545     var newFCarry = ((parentObj.registerA & 0x01) == 0x01);
2546     parentObj.registerA = ((parentObj.FCarry) ? 0x80 : 0) | (parentObj.registerA >> 1);
2547     parentObj.FCarry = newFCarry;
2548     parentObj.FHalfCarry = parentObj.FSubtract = false;
2549     parentObj.FZero = (parentObj.registerA == 0);
2550   }
2551   //SLA B
2552   //#0x20:
2553   ,function (parentObj) {
2554     parentObj.FCarry = (parentObj.registerB > 0x7F);
2555     parentObj.registerB = (parentObj.registerB << 1) & 0xFF;
2556     parentObj.FHalfCarry = parentObj.FSubtract = false;
2557     parentObj.FZero = (parentObj.registerB == 0);
2558   }
2559   //SLA C
2560   //#0x21:
2561   ,function (parentObj) {
2562     parentObj.FCarry = (parentObj.registerC > 0x7F);
2563     parentObj.registerC = (parentObj.registerC << 1) & 0xFF;
2564     parentObj.FHalfCarry = parentObj.FSubtract = false;
2565     parentObj.FZero = (parentObj.registerC == 0);
2566   }
2567   //SLA D
2568   //#0x22:
2569   ,function (parentObj) {
2570     parentObj.FCarry = (parentObj.registerD > 0x7F);
2571     parentObj.registerD = (parentObj.registerD << 1) & 0xFF;
2572     parentObj.FHalfCarry = parentObj.FSubtract = false;
2573     parentObj.FZero = (parentObj.registerD == 0);
2574   }
2575   //SLA E
2576   //#0x23:
2577   ,function (parentObj) {
2578     parentObj.FCarry = (parentObj.registerE > 0x7F);
2579     parentObj.registerE = (parentObj.registerE << 1) & 0xFF;
2580     parentObj.FHalfCarry = parentObj.FSubtract = false;
2581     parentObj.FZero = (parentObj.registerE == 0);
2582   }
2583   //SLA H
2584   //#0x24:
2585   ,function (parentObj) {
2586     parentObj.FCarry = (parentObj.registersHL > 0x7FFF);
2587     parentObj.registersHL = ((parentObj.registersHL << 1) & 0xFE00) | (parentObj.registersHL & 0xFF);
2588     parentObj.FHalfCarry = parentObj.FSubtract = false;
2589     parentObj.FZero = (parentObj.registersHL < 0x100);
2590   }
2591   //SLA L
2592   //#0x25:
2593   ,function (parentObj) {
2594     parentObj.FCarry = ((parentObj.registersHL & 0x0080) == 0x0080);
2595     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | ((parentObj.registersHL << 1) & 0xFF);
2596     parentObj.FHalfCarry = parentObj.FSubtract = false;
2597     parentObj.FZero = ((parentObj.registersHL & 0xFF) == 0);
2598   }
2599   //SLA (HL)
2600   //#0x26:
2601   ,function (parentObj) {
2602     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
2603     parentObj.FCarry = (temp_var > 0x7F);
2604     temp_var = (temp_var << 1) & 0xFF;
2605     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
2606     parentObj.FHalfCarry = parentObj.FSubtract = false;
2607     parentObj.FZero = (temp_var == 0);
2608   }
2609   //SLA A
2610   //#0x27:
2611   ,function (parentObj) {
2612     parentObj.FCarry = (parentObj.registerA > 0x7F);
2613     parentObj.registerA = (parentObj.registerA << 1) & 0xFF;
2614     parentObj.FHalfCarry = parentObj.FSubtract = false;
2615     parentObj.FZero = (parentObj.registerA == 0);
2616   }
2617   //SRA B
2618   //#0x28:
2619   ,function (parentObj) {
2620     parentObj.FCarry = ((parentObj.registerB & 0x01) == 0x01);
2621     parentObj.registerB = (parentObj.registerB & 0x80) | (parentObj.registerB >> 1);
2622     parentObj.FHalfCarry = parentObj.FSubtract = false;
2623     parentObj.FZero = (parentObj.registerB == 0);
2624   }
2625   //SRA C
2626   //#0x29:
2627   ,function (parentObj) {
2628     parentObj.FCarry = ((parentObj.registerC & 0x01) == 0x01);
2629     parentObj.registerC = (parentObj.registerC & 0x80) | (parentObj.registerC >> 1);
2630     parentObj.FHalfCarry = parentObj.FSubtract = false;
2631     parentObj.FZero = (parentObj.registerC == 0);
2632   }
2633   //SRA D
2634   //#0x2A:
2635   ,function (parentObj) {
2636     parentObj.FCarry = ((parentObj.registerD & 0x01) == 0x01);
2637     parentObj.registerD = (parentObj.registerD & 0x80) | (parentObj.registerD >> 1);
2638     parentObj.FHalfCarry = parentObj.FSubtract = false;
2639     parentObj.FZero = (parentObj.registerD == 0);
2640   }
2641   //SRA E
2642   //#0x2B:
2643   ,function (parentObj) {
2644     parentObj.FCarry = ((parentObj.registerE & 0x01) == 0x01);
2645     parentObj.registerE = (parentObj.registerE & 0x80) | (parentObj.registerE >> 1);
2646     parentObj.FHalfCarry = parentObj.FSubtract = false;
2647     parentObj.FZero = (parentObj.registerE == 0);
2648   }
2649   //SRA H
2650   //#0x2C:
2651   ,function (parentObj) {
2652     parentObj.FCarry = ((parentObj.registersHL & 0x0100) == 0x0100);
2653     parentObj.registersHL = ((parentObj.registersHL >> 1) & 0xFF00) | (parentObj.registersHL & 0x80FF);
2654     parentObj.FHalfCarry = parentObj.FSubtract = false;
2655     parentObj.FZero = (parentObj.registersHL < 0x100);
2656   }
2657   //SRA L
2658   //#0x2D:
2659   ,function (parentObj) {
2660     parentObj.FCarry = ((parentObj.registersHL & 0x0001) == 0x0001);
2661     parentObj.registersHL = (parentObj.registersHL & 0xFF80) | ((parentObj.registersHL & 0xFF) >> 1);
2662     parentObj.FHalfCarry = parentObj.FSubtract = false;
2663     parentObj.FZero = ((parentObj.registersHL & 0xFF) == 0);
2664   }
2665   //SRA (HL)
2666   //#0x2E:
2667   ,function (parentObj) {
2668     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
2669     parentObj.FCarry = ((temp_var & 0x01) == 0x01);
2670     temp_var = (temp_var & 0x80) | (temp_var >> 1);
2671     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
2672     parentObj.FHalfCarry = parentObj.FSubtract = false;
2673     parentObj.FZero = (temp_var == 0);
2674   }
2675   //SRA A
2676   //#0x2F:
2677   ,function (parentObj) {
2678     parentObj.FCarry = ((parentObj.registerA & 0x01) == 0x01);
2679     parentObj.registerA = (parentObj.registerA & 0x80) | (parentObj.registerA >> 1);
2680     parentObj.FHalfCarry = parentObj.FSubtract = false;
2681     parentObj.FZero = (parentObj.registerA == 0);
2682   }
2683   //SWAP B
2684   //#0x30:
2685   ,function (parentObj) {
2686     parentObj.registerB = ((parentObj.registerB & 0xF) << 4) | (parentObj.registerB >> 4);
2687     parentObj.FZero = (parentObj.registerB == 0);
2688     parentObj.FCarry = parentObj.FHalfCarry = parentObj.FSubtract = false;
2689   }
2690   //SWAP C
2691   //#0x31:
2692   ,function (parentObj) {
2693     parentObj.registerC = ((parentObj.registerC & 0xF) << 4) | (parentObj.registerC >> 4);
2694     parentObj.FZero = (parentObj.registerC == 0);
2695     parentObj.FCarry = parentObj.FHalfCarry = parentObj.FSubtract = false;
2696   }
2697   //SWAP D
2698   //#0x32:
2699   ,function (parentObj) {
2700     parentObj.registerD = ((parentObj.registerD & 0xF) << 4) | (parentObj.registerD >> 4);
2701     parentObj.FZero = (parentObj.registerD == 0);
2702     parentObj.FCarry = parentObj.FHalfCarry = parentObj.FSubtract = false;
2703   }
2704   //SWAP E
2705   //#0x33:
2706   ,function (parentObj) {
2707     parentObj.registerE = ((parentObj.registerE & 0xF) << 4) | (parentObj.registerE >> 4);
2708     parentObj.FZero = (parentObj.registerE == 0);
2709     parentObj.FCarry = parentObj.FHalfCarry = parentObj.FSubtract = false;
2710   }
2711   //SWAP H
2712   //#0x34:
2713   ,function (parentObj) {
2714     parentObj.registersHL = ((parentObj.registersHL & 0xF00) << 4) | ((parentObj.registersHL & 0xF000) >> 4) | (parentObj.registersHL & 0xFF);
2715     parentObj.FZero = (parentObj.registersHL < 0x100);
2716     parentObj.FCarry = parentObj.FHalfCarry = parentObj.FSubtract = false;
2717   }
2718   //SWAP L
2719   //#0x35:
2720   ,function (parentObj) {
2721     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | ((parentObj.registersHL & 0xF) << 4) | ((parentObj.registersHL & 0xF0) >> 4);
2722     parentObj.FZero = ((parentObj.registersHL & 0xFF) == 0);
2723     parentObj.FCarry = parentObj.FHalfCarry = parentObj.FSubtract = false;
2724   }
2725   //SWAP (HL)
2726   //#0x36:
2727   ,function (parentObj) {
2728     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
2729     temp_var = ((temp_var & 0xF) << 4) | (temp_var >> 4);
2730     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var);
2731     parentObj.FZero = (temp_var == 0);
2732     parentObj.FCarry = parentObj.FHalfCarry = parentObj.FSubtract = false;
2733   }
2734   //SWAP A
2735   //#0x37:
2736   ,function (parentObj) {
2737     parentObj.registerA = ((parentObj.registerA & 0xF) << 4) | (parentObj.registerA >> 4);
2738     parentObj.FZero = (parentObj.registerA == 0);
2739     parentObj.FCarry = parentObj.FHalfCarry = parentObj.FSubtract = false;
2740   }
2741   //SRL B
2742   //#0x38:
2743   ,function (parentObj) {
2744     parentObj.FCarry = ((parentObj.registerB & 0x01) == 0x01);
2745     parentObj.registerB >>= 1;
2746     parentObj.FHalfCarry = parentObj.FSubtract = false;
2747     parentObj.FZero = (parentObj.registerB == 0);
2748   }
2749   //SRL C
2750   //#0x39:
2751   ,function (parentObj) {
2752     parentObj.FCarry = ((parentObj.registerC & 0x01) == 0x01);
2753     parentObj.registerC >>= 1;
2754     parentObj.FHalfCarry = parentObj.FSubtract = false;
2755     parentObj.FZero = (parentObj.registerC == 0);
2756   }
2757   //SRL D
2758   //#0x3A:
2759   ,function (parentObj) {
2760     parentObj.FCarry = ((parentObj.registerD & 0x01) == 0x01);
2761     parentObj.registerD >>= 1;
2762     parentObj.FHalfCarry = parentObj.FSubtract = false;
2763     parentObj.FZero = (parentObj.registerD == 0);
2764   }
2765   //SRL E
2766   //#0x3B:
2767   ,function (parentObj) {
2768     parentObj.FCarry = ((parentObj.registerE & 0x01) == 0x01);
2769     parentObj.registerE >>= 1;
2770     parentObj.FHalfCarry = parentObj.FSubtract = false;
2771     parentObj.FZero = (parentObj.registerE == 0);
2772   }
2773   //SRL H
2774   //#0x3C:
2775   ,function (parentObj) {
2776     parentObj.FCarry = ((parentObj.registersHL & 0x0100) == 0x0100);
2777     parentObj.registersHL = ((parentObj.registersHL >> 1) & 0xFF00) | (parentObj.registersHL & 0xFF);
2778     parentObj.FHalfCarry = parentObj.FSubtract = false;
2779     parentObj.FZero = (parentObj.registersHL < 0x100);
2780   }
2781   //SRL L
2782   //#0x3D:
2783   ,function (parentObj) {
2784     parentObj.FCarry = ((parentObj.registersHL & 0x0001) == 0x0001);
2785     parentObj.registersHL = (parentObj.registersHL & 0xFF00) | ((parentObj.registersHL & 0xFF) >> 1);
2786     parentObj.FHalfCarry = parentObj.FSubtract = false;
2787     parentObj.FZero = ((parentObj.registersHL & 0xFF) == 0);
2788   }
2789   //SRL (HL)
2790   //#0x3E:
2791   ,function (parentObj) {
2792     var temp_var = parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL);
2793     parentObj.FCarry = ((temp_var & 0x01) == 0x01);
2794     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, temp_var >> 1);
2795     parentObj.FHalfCarry = parentObj.FSubtract = false;
2796     parentObj.FZero = (temp_var < 2);
2797   }
2798   //SRL A
2799   //#0x3F:
2800   ,function (parentObj) {
2801     parentObj.FCarry = ((parentObj.registerA & 0x01) == 0x01);
2802     parentObj.registerA >>= 1;
2803     parentObj.FHalfCarry = parentObj.FSubtract = false;
2804     parentObj.FZero = (parentObj.registerA == 0);
2805   }
2806   //BIT 0, B
2807   //#0x40:
2808   ,function (parentObj) {
2809     parentObj.FHalfCarry = true;
2810     parentObj.FSubtract = false;
2811     parentObj.FZero = ((parentObj.registerB & 0x01) == 0);
2812   }
2813   //BIT 0, C
2814   //#0x41:
2815   ,function (parentObj) {
2816     parentObj.FHalfCarry = true;
2817     parentObj.FSubtract = false;
2818     parentObj.FZero = ((parentObj.registerC & 0x01) == 0);
2819   }
2820   //BIT 0, D
2821   //#0x42:
2822   ,function (parentObj) {
2823     parentObj.FHalfCarry = true;
2824     parentObj.FSubtract = false;
2825     parentObj.FZero = ((parentObj.registerD & 0x01) == 0);
2826   }
2827   //BIT 0, E
2828   //#0x43:
2829   ,function (parentObj) {
2830     parentObj.FHalfCarry = true;
2831     parentObj.FSubtract = false;
2832     parentObj.FZero = ((parentObj.registerE & 0x01) == 0);
2833   }
2834   //BIT 0, H
2835   //#0x44:
2836   ,function (parentObj) {
2837     parentObj.FHalfCarry = true;
2838     parentObj.FSubtract = false;
2839     parentObj.FZero = ((parentObj.registersHL & 0x0100) == 0);
2840   }
2841   //BIT 0, L
2842   //#0x45:
2843   ,function (parentObj) {
2844     parentObj.FHalfCarry = true;
2845     parentObj.FSubtract = false;
2846     parentObj.FZero = ((parentObj.registersHL & 0x0001) == 0);
2847   }
2848   //BIT 0, (HL)
2849   //#0x46:
2850   ,function (parentObj) {
2851     parentObj.FHalfCarry = true;
2852     parentObj.FSubtract = false;
2853     parentObj.FZero = ((parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0x01) == 0);
2854   }
2855   //BIT 0, A
2856   //#0x47:
2857   ,function (parentObj) {
2858     parentObj.FHalfCarry = true;
2859     parentObj.FSubtract = false;
2860     parentObj.FZero = ((parentObj.registerA & 0x01) == 0);
2861   }
2862   //BIT 1, B
2863   //#0x48:
2864   ,function (parentObj) {
2865     parentObj.FHalfCarry = true;
2866     parentObj.FSubtract = false;
2867     parentObj.FZero = ((parentObj.registerB & 0x02) == 0);
2868   }
2869   //BIT 1, C
2870   //#0x49:
2871   ,function (parentObj) {
2872     parentObj.FHalfCarry = true;
2873     parentObj.FSubtract = false;
2874     parentObj.FZero = ((parentObj.registerC & 0x02) == 0);
2875   }
2876   //BIT 1, D
2877   //#0x4A:
2878   ,function (parentObj) {
2879     parentObj.FHalfCarry = true;
2880     parentObj.FSubtract = false;
2881     parentObj.FZero = ((parentObj.registerD & 0x02) == 0);
2882   }
2883   //BIT 1, E
2884   //#0x4B:
2885   ,function (parentObj) {
2886     parentObj.FHalfCarry = true;
2887     parentObj.FSubtract = false;
2888     parentObj.FZero = ((parentObj.registerE & 0x02) == 0);
2889   }
2890   //BIT 1, H
2891   //#0x4C:
2892   ,function (parentObj) {
2893     parentObj.FHalfCarry = true;
2894     parentObj.FSubtract = false;
2895     parentObj.FZero = ((parentObj.registersHL & 0x0200) == 0);
2896   }
2897   //BIT 1, L
2898   //#0x4D:
2899   ,function (parentObj) {
2900     parentObj.FHalfCarry = true;
2901     parentObj.FSubtract = false;
2902     parentObj.FZero = ((parentObj.registersHL & 0x0002) == 0);
2903   }
2904   //BIT 1, (HL)
2905   //#0x4E:
2906   ,function (parentObj) {
2907     parentObj.FHalfCarry = true;
2908     parentObj.FSubtract = false;
2909     parentObj.FZero = ((parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0x02) == 0);
2910   }
2911   //BIT 1, A
2912   //#0x4F:
2913   ,function (parentObj) {
2914     parentObj.FHalfCarry = true;
2915     parentObj.FSubtract = false;
2916     parentObj.FZero = ((parentObj.registerA & 0x02) == 0);
2917   }
2918   //BIT 2, B
2919   //#0x50:
2920   ,function (parentObj) {
2921     parentObj.FHalfCarry = true;
2922     parentObj.FSubtract = false;
2923     parentObj.FZero = ((parentObj.registerB & 0x04) == 0);
2924   }
2925   //BIT 2, C
2926   //#0x51:
2927   ,function (parentObj) {
2928     parentObj.FHalfCarry = true;
2929     parentObj.FSubtract = false;
2930     parentObj.FZero = ((parentObj.registerC & 0x04) == 0);
2931   }
2932   //BIT 2, D
2933   //#0x52:
2934   ,function (parentObj) {
2935     parentObj.FHalfCarry = true;
2936     parentObj.FSubtract = false;
2937     parentObj.FZero = ((parentObj.registerD & 0x04) == 0);
2938   }
2939   //BIT 2, E
2940   //#0x53:
2941   ,function (parentObj) {
2942     parentObj.FHalfCarry = true;
2943     parentObj.FSubtract = false;
2944     parentObj.FZero = ((parentObj.registerE & 0x04) == 0);
2945   }
2946   //BIT 2, H
2947   //#0x54:
2948   ,function (parentObj) {
2949     parentObj.FHalfCarry = true;
2950     parentObj.FSubtract = false;
2951     parentObj.FZero = ((parentObj.registersHL & 0x0400) == 0);
2952   }
2953   //BIT 2, L
2954   //#0x55:
2955   ,function (parentObj) {
2956     parentObj.FHalfCarry = true;
2957     parentObj.FSubtract = false;
2958     parentObj.FZero = ((parentObj.registersHL & 0x0004) == 0);
2959   }
2960   //BIT 2, (HL)
2961   //#0x56:
2962   ,function (parentObj) {
2963     parentObj.FHalfCarry = true;
2964     parentObj.FSubtract = false;
2965     parentObj.FZero = ((parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0x04) == 0);
2966   }
2967   //BIT 2, A
2968   //#0x57:
2969   ,function (parentObj) {
2970     parentObj.FHalfCarry = true;
2971     parentObj.FSubtract = false;
2972     parentObj.FZero = ((parentObj.registerA & 0x04) == 0);
2973   }
2974   //BIT 3, B
2975   //#0x58:
2976   ,function (parentObj) {
2977     parentObj.FHalfCarry = true;
2978     parentObj.FSubtract = false;
2979     parentObj.FZero = ((parentObj.registerB & 0x08) == 0);
2980   }
2981   //BIT 3, C
2982   //#0x59:
2983   ,function (parentObj) {
2984     parentObj.FHalfCarry = true;
2985     parentObj.FSubtract = false;
2986     parentObj.FZero = ((parentObj.registerC & 0x08) == 0);
2987   }
2988   //BIT 3, D
2989   //#0x5A:
2990   ,function (parentObj) {
2991     parentObj.FHalfCarry = true;
2992     parentObj.FSubtract = false;
2993     parentObj.FZero = ((parentObj.registerD & 0x08) == 0);
2994   }
2995   //BIT 3, E
2996   //#0x5B:
2997   ,function (parentObj) {
2998     parentObj.FHalfCarry = true;
2999     parentObj.FSubtract = false;
3000     parentObj.FZero = ((parentObj.registerE & 0x08) == 0);
3001   }
3002   //BIT 3, H
3003   //#0x5C:
3004   ,function (parentObj) {
3005     parentObj.FHalfCarry = true;
3006     parentObj.FSubtract = false;
3007     parentObj.FZero = ((parentObj.registersHL & 0x0800) == 0);
3008   }
3009   //BIT 3, L
3010   //#0x5D:
3011   ,function (parentObj) {
3012     parentObj.FHalfCarry = true;
3013     parentObj.FSubtract = false;
3014     parentObj.FZero = ((parentObj.registersHL & 0x0008) == 0);
3015   }
3016   //BIT 3, (HL)
3017   //#0x5E:
3018   ,function (parentObj) {
3019     parentObj.FHalfCarry = true;
3020     parentObj.FSubtract = false;
3021     parentObj.FZero = ((parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0x08) == 0);
3022   }
3023   //BIT 3, A
3024   //#0x5F:
3025   ,function (parentObj) {
3026     parentObj.FHalfCarry = true;
3027     parentObj.FSubtract = false;
3028     parentObj.FZero = ((parentObj.registerA & 0x08) == 0);
3029   }
3030   //BIT 4, B
3031   //#0x60:
3032   ,function (parentObj) {
3033     parentObj.FHalfCarry = true;
3034     parentObj.FSubtract = false;
3035     parentObj.FZero = ((parentObj.registerB & 0x10) == 0);
3036   }
3037   //BIT 4, C
3038   //#0x61:
3039   ,function (parentObj) {
3040     parentObj.FHalfCarry = true;
3041     parentObj.FSubtract = false;
3042     parentObj.FZero = ((parentObj.registerC & 0x10) == 0);
3043   }
3044   //BIT 4, D
3045   //#0x62:
3046   ,function (parentObj) {
3047     parentObj.FHalfCarry = true;
3048     parentObj.FSubtract = false;
3049     parentObj.FZero = ((parentObj.registerD & 0x10) == 0);
3050   }
3051   //BIT 4, E
3052   //#0x63:
3053   ,function (parentObj) {
3054     parentObj.FHalfCarry = true;
3055     parentObj.FSubtract = false;
3056     parentObj.FZero = ((parentObj.registerE & 0x10) == 0);
3057   }
3058   //BIT 4, H
3059   //#0x64:
3060   ,function (parentObj) {
3061     parentObj.FHalfCarry = true;
3062     parentObj.FSubtract = false;
3063     parentObj.FZero = ((parentObj.registersHL & 0x1000) == 0);
3064   }
3065   //BIT 4, L
3066   //#0x65:
3067   ,function (parentObj) {
3068     parentObj.FHalfCarry = true;
3069     parentObj.FSubtract = false;
3070     parentObj.FZero = ((parentObj.registersHL & 0x0010) == 0);
3071   }
3072   //BIT 4, (HL)
3073   //#0x66:
3074   ,function (parentObj) {
3075     parentObj.FHalfCarry = true;
3076     parentObj.FSubtract = false;
3077     parentObj.FZero = ((parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0x10) == 0);
3078   }
3079   //BIT 4, A
3080   //#0x67:
3081   ,function (parentObj) {
3082     parentObj.FHalfCarry = true;
3083     parentObj.FSubtract = false;
3084     parentObj.FZero = ((parentObj.registerA & 0x10) == 0);
3085   }
3086   //BIT 5, B
3087   //#0x68:
3088   ,function (parentObj) {
3089     parentObj.FHalfCarry = true;
3090     parentObj.FSubtract = false;
3091     parentObj.FZero = ((parentObj.registerB & 0x20) == 0);
3092   }
3093   //BIT 5, C
3094   //#0x69:
3095   ,function (parentObj) {
3096     parentObj.FHalfCarry = true;
3097     parentObj.FSubtract = false;
3098     parentObj.FZero = ((parentObj.registerC & 0x20) == 0);
3099   }
3100   //BIT 5, D
3101   //#0x6A:
3102   ,function (parentObj) {
3103     parentObj.FHalfCarry = true;
3104     parentObj.FSubtract = false;
3105     parentObj.FZero = ((parentObj.registerD & 0x20) == 0);
3106   }
3107   //BIT 5, E
3108   //#0x6B:
3109   ,function (parentObj) {
3110     parentObj.FHalfCarry = true;
3111     parentObj.FSubtract = false;
3112     parentObj.FZero = ((parentObj.registerE & 0x20) == 0);
3113   }
3114   //BIT 5, H
3115   //#0x6C:
3116   ,function (parentObj) {
3117     parentObj.FHalfCarry = true;
3118     parentObj.FSubtract = false;
3119     parentObj.FZero = ((parentObj.registersHL & 0x2000) == 0);
3120   }
3121   //BIT 5, L
3122   //#0x6D:
3123   ,function (parentObj) {
3124     parentObj.FHalfCarry = true;
3125     parentObj.FSubtract = false;
3126     parentObj.FZero = ((parentObj.registersHL & 0x0020) == 0);
3127   }
3128   //BIT 5, (HL)
3129   //#0x6E:
3130   ,function (parentObj) {
3131     parentObj.FHalfCarry = true;
3132     parentObj.FSubtract = false;
3133     parentObj.FZero = ((parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0x20) == 0);
3134   }
3135   //BIT 5, A
3136   //#0x6F:
3137   ,function (parentObj) {
3138     parentObj.FHalfCarry = true;
3139     parentObj.FSubtract = false;
3140     parentObj.FZero = ((parentObj.registerA & 0x20) == 0);
3141   }
3142   //BIT 6, B
3143   //#0x70:
3144   ,function (parentObj) {
3145     parentObj.FHalfCarry = true;
3146     parentObj.FSubtract = false;
3147     parentObj.FZero = ((parentObj.registerB & 0x40) == 0);
3148   }
3149   //BIT 6, C
3150   //#0x71:
3151   ,function (parentObj) {
3152     parentObj.FHalfCarry = true;
3153     parentObj.FSubtract = false;
3154     parentObj.FZero = ((parentObj.registerC & 0x40) == 0);
3155   }
3156   //BIT 6, D
3157   //#0x72:
3158   ,function (parentObj) {
3159     parentObj.FHalfCarry = true;
3160     parentObj.FSubtract = false;
3161     parentObj.FZero = ((parentObj.registerD & 0x40) == 0);
3162   }
3163   //BIT 6, E
3164   //#0x73:
3165   ,function (parentObj) {
3166     parentObj.FHalfCarry = true;
3167     parentObj.FSubtract = false;
3168     parentObj.FZero = ((parentObj.registerE & 0x40) == 0);
3169   }
3170   //BIT 6, H
3171   //#0x74:
3172   ,function (parentObj) {
3173     parentObj.FHalfCarry = true;
3174     parentObj.FSubtract = false;
3175     parentObj.FZero = ((parentObj.registersHL & 0x4000) == 0);
3176   }
3177   //BIT 6, L
3178   //#0x75:
3179   ,function (parentObj) {
3180     parentObj.FHalfCarry = true;
3181     parentObj.FSubtract = false;
3182     parentObj.FZero = ((parentObj.registersHL & 0x0040) == 0);
3183   }
3184   //BIT 6, (HL)
3185   //#0x76:
3186   ,function (parentObj) {
3187     parentObj.FHalfCarry = true;
3188     parentObj.FSubtract = false;
3189     parentObj.FZero = ((parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0x40) == 0);
3190   }
3191   //BIT 6, A
3192   //#0x77:
3193   ,function (parentObj) {
3194     parentObj.FHalfCarry = true;
3195     parentObj.FSubtract = false;
3196     parentObj.FZero = ((parentObj.registerA & 0x40) == 0);
3197   }
3198   //BIT 7, B
3199   //#0x78:
3200   ,function (parentObj) {
3201     parentObj.FHalfCarry = true;
3202     parentObj.FSubtract = false;
3203     parentObj.FZero = ((parentObj.registerB & 0x80) == 0);
3204   }
3205   //BIT 7, C
3206   //#0x79:
3207   ,function (parentObj) {
3208     parentObj.FHalfCarry = true;
3209     parentObj.FSubtract = false;
3210     parentObj.FZero = ((parentObj.registerC & 0x80) == 0);
3211   }
3212   //BIT 7, D
3213   //#0x7A:
3214   ,function (parentObj) {
3215     parentObj.FHalfCarry = true;
3216     parentObj.FSubtract = false;
3217     parentObj.FZero = ((parentObj.registerD & 0x80) == 0);
3218   }
3219   //BIT 7, E
3220   //#0x7B:
3221   ,function (parentObj) {
3222     parentObj.FHalfCarry = true;
3223     parentObj.FSubtract = false;
3224     parentObj.FZero = ((parentObj.registerE & 0x80) == 0);
3225   }
3226   //BIT 7, H
3227   //#0x7C:
3228   ,function (parentObj) {
3229     parentObj.FHalfCarry = true;
3230     parentObj.FSubtract = false;
3231     parentObj.FZero = ((parentObj.registersHL & 0x8000) == 0);
3232   }
3233   //BIT 7, L
3234   //#0x7D:
3235   ,function (parentObj) {
3236     parentObj.FHalfCarry = true;
3237     parentObj.FSubtract = false;
3238     parentObj.FZero = ((parentObj.registersHL & 0x0080) == 0);
3239   }
3240   //BIT 7, (HL)
3241   //#0x7E:
3242   ,function (parentObj) {
3243     parentObj.FHalfCarry = true;
3244     parentObj.FSubtract = false;
3245     parentObj.FZero = ((parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0x80) == 0);
3246   }
3247   //BIT 7, A
3248   //#0x7F:
3249   ,function (parentObj) {
3250     parentObj.FHalfCarry = true;
3251     parentObj.FSubtract = false;
3252     parentObj.FZero = ((parentObj.registerA & 0x80) == 0);
3253   }
3254   //RES 0, B
3255   //#0x80:
3256   ,function (parentObj) {
3257     parentObj.registerB &= 0xFE;
3258   }
3259   //RES 0, C
3260   //#0x81:
3261   ,function (parentObj) {
3262     parentObj.registerC &= 0xFE;
3263   }
3264   //RES 0, D
3265   //#0x82:
3266   ,function (parentObj) {
3267     parentObj.registerD &= 0xFE;
3268   }
3269   //RES 0, E
3270   //#0x83:
3271   ,function (parentObj) {
3272     parentObj.registerE &= 0xFE;
3273   }
3274   //RES 0, H
3275   //#0x84:
3276   ,function (parentObj) {
3277     parentObj.registersHL &= 0xFEFF;
3278   }
3279   //RES 0, L
3280   //#0x85:
3281   ,function (parentObj) {
3282     parentObj.registersHL &= 0xFFFE;
3283   }
3284   //RES 0, (HL)
3285   //#0x86:
3286   ,function (parentObj) {
3287     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0xFE);
3288   }
3289   //RES 0, A
3290   //#0x87:
3291   ,function (parentObj) {
3292     parentObj.registerA &= 0xFE;
3293   }
3294   //RES 1, B
3295   //#0x88:
3296   ,function (parentObj) {
3297     parentObj.registerB &= 0xFD;
3298   }
3299   //RES 1, C
3300   //#0x89:
3301   ,function (parentObj) {
3302     parentObj.registerC &= 0xFD;
3303   }
3304   //RES 1, D
3305   //#0x8A:
3306   ,function (parentObj) {
3307     parentObj.registerD &= 0xFD;
3308   }
3309   //RES 1, E
3310   //#0x8B:
3311   ,function (parentObj) {
3312     parentObj.registerE &= 0xFD;
3313   }
3314   //RES 1, H
3315   //#0x8C:
3316   ,function (parentObj) {
3317     parentObj.registersHL &= 0xFDFF;
3318   }
3319   //RES 1, L
3320   //#0x8D:
3321   ,function (parentObj) {
3322     parentObj.registersHL &= 0xFFFD;
3323   }
3324   //RES 1, (HL)
3325   //#0x8E:
3326   ,function (parentObj) {
3327     parentObj.memoryWriter[parentObj.registersHL](parentObj, parentObj.registersHL, parentObj.memoryReader[parentObj.registersHL](parentObj, parentObj.registersHL) & 0xFD);
3328   }
3329   //RES 1, A
3330   //#0x8F:
3331   ,function (parentObj) {
3332     parentObj.registerA &= 0xFD;
3333   }
3334   //RES 2, B
3335   //#0x90:
3336   ,function (parentObj) {
3337     parentObj.registerB &= 0xFB;
3338   }
3339   //RES 2, C
3340   //#0x91:
3341   ,function (parentObj) {
3342     parentObj.registerC &= 0xFB;
3343   }
3344   //RES 2, D
3345   //#0x92:
3346   ,function (parentObj) {
3347     parentObj.registerD &= 0xFB;
3348   }
3349   //RES 2, E
3350   //#0x93:
3351   ,function (parentObj) {
3352     parentObj.registerE &= 0xFB;
3353   }
3354   //RES 2, H
3355   //#0x94:
3356   ,function (parentObj) {
3357     parentObj.registersHL &= 0xFBFF;
3358   }
3359   //RES 2, L
3360   //#0x95:
3361   ,function (parentObj) {
3362     parentObj.registersHL &= 0xFFFB;
3363   }
3364   //RES 2, (HL)