function loadboot(p) {
    var boot = [
        0x31, 0xFE, 0xFF, 0xAF, 0x21, 0xFF, 0x9F, 0x32, 0xCB, 0x7C, 0x20, 0xFB, 0x21, 0x26, 0xFF, 0x0E,
        0x11, 0x3E, 0x80, 0x32, 0xE2, 0x0C, 0x3E, 0xF3, 0xE2, 0x32, 0x3E, 0x77, 0x77, 0x3E, 0xFC, 0xE0,
        0x47, 0x11, 0x04, 0x01, 0x21, 0x10, 0x80, 0x1A, 0xCD, 0x95, 0x00, 0xCD, 0x96, 0x00, 0x13, 0x7B,
        0xFE, 0x34, 0x20, 0xF3, 0x11, 0xD8, 0x00, 0x06, 0x08, 0x1A, 0x13, 0x22, 0x23, 0x05, 0x20, 0xF9,
        0x3E, 0x19, 0xEA, 0x10, 0x99, 0x21, 0x2F, 0x99, 0x0E, 0x0C, 0x3D, 0x28, 0x08, 0x32, 0x0D, 0x20,
        0xF9, 0x2E, 0x0F, 0x18, 0xF3, 0x67, 0x3E, 0x64, 0x57, 0xE0, 0x42, 0x3E, 0x91, 0xE0, 0x40, 0x04,
        0x1E, 0x02, 0x0E, 0x0C, 0xF0, 0x44, 0xFE, 0x90, 0x20, 0xFA, 0x0D, 0x20, 0xF7, 0x1D, 0x20, 0xF2,
        0x0E, 0x13, 0x24, 0x7C, 0x1E, 0x83, 0xFE, 0x62, 0x28, 0x06, 0x1E, 0xC1, 0xFE, 0x64, 0x20, 0x06,
        0x7B, 0xE2, 0x0C, 0x3E, 0x87, 0xE2, 0xF0, 0x42, 0x90, 0xE0, 0x42, 0x15, 0x20, 0xD2, 0x05, 0x20,
        0x4F, 0x16, 0x20, 0x18, 0xCB, 0x4F, 0x06, 0x04, 0xC5, 0xCB, 0x11, 0x17, 0xC1, 0xCB, 0x11, 0x17,
        0x05, 0x20, 0xF5, 0x22, 0x23, 0x22, 0x23, 0xC9, 0xCE, 0xED, 0x66, 0x66, 0xCC, 0x0D, 0x00, 0x0B,
        0x03, 0x73, 0x00, 0x83, 0x00, 0x0C, 0x00, 0x0D, 0x00, 0x08, 0x11, 0x1F, 0x88, 0x89, 0x00, 0x0E,
        0xDC, 0xCC, 0x6E, 0xE6, 0xDD, 0xDD, 0xD9, 0x99, 0xBB, 0xBB, 0x67, 0x63, 0x6E, 0x0E, 0xEC, 0xCC,
        0xDD, 0xDC, 0x99, 0x9F, 0xBB, 0xB9, 0x33, 0x3E, 0x3C, 0x42, 0xB9, 0xA5, 0xB9, 0xA5, 0x42, 0x3C,
        0x21, 0x04, 0x01, 0x11, 0xA8, 0x00, 0x1A, 0x13, 0xBE, 0x00, 0x00, 0x23, 0x7D, 0xFE, 0x34, 0x20,
        0xF5, 0x06, 0x19, 0x78, 0x86, 0x23, 0x05, 0x20, 0xFB, 0x86, 0x00, 0x00, 0x3E, 0x01, 0xE0, 0x50
    ];

    for (var i in boot) {
        p.memory[i] = boot[i];
    }
    p.r.pc = 0;
    p.usingBootRom = true;
}

var GameboyJS;
(function (GameboyJS) {
"use strict";

// CPU class
var CPU = function(gameboy) {
    this.gameboy = gameboy;

    this.r = {A:0, F: 0, B:0, C:0, D:0, E:0, H:0, L:0, pc:0, sp:0};
    this.IME = true;
    this.clock = {c: 0, serial: 0};
    this.isHalted = false;
    this.isPaused = false;
    this.usingBootRom = false;

    this.createDevices();
};

CPU.INTERRUPTS = {
    VBLANK: 0,
    LCDC:   1,
    TIMER:  2,
    SERIAL: 3,
    HILO:   4
};
CPU.interruptRoutines = {
    0: function(p){GameboyJS.cpuOps.RSTn(p, 0x40);},
    1: function(p){GameboyJS.cpuOps.RSTn(p, 0x48);},
    2: function(p){GameboyJS.cpuOps.RSTn(p, 0x50);},
    3: function(p){GameboyJS.cpuOps.RSTn(p, 0x58);},
    4: function(p){GameboyJS.cpuOps.RSTn(p, 0x60);}
};

CPU.prototype.createDevices = function() {
    this.memory = new GameboyJS.Memory(this);
    this.timer = new GameboyJS.Timer(this, this.memory);
    this.apu = new GameboyJS.APU(this.memory);

    this.SERIAL_INTERNAL_INSTR = 512; // instr to wait per bit if internal clock
    this.enableSerial = 0;
    this.serialHandler = GameboyJS.ConsoleSerial;
};

CPU.prototype.reset = function() {
    this.memory.reset();

    this.r.sp = 0xFFFE;
};

CPU.prototype.loadRom = function(data) {
    this.memory.setRomData(data);
};

CPU.prototype.getRamSize = function() {
    var size = 0;
    switch (this.memory.rb(0x149)) {
        case 1:
            size = 2048;
            break;
        case 2:
            size = 2048 * 4;
            break;
        case 3:
            size = 2048 * 16;
            break;
    }

    return size;
};

CPU.prototype.getGameName = function() {
    var name = '';
    for (var i = 0x134; i < 0x143; i++) {
        var char = this.memory.rb(i) || 32;
        name += String.fromCharCode(char);
    }

    return name;
};

// Start the execution of the emulator
CPU.prototype.run = function() {
    if (this.usingBootRom) {
        this.r.pc = 0x0000;
    } else {
        this.r.pc = 0x0100;
    }
    this.frame();
};

CPU.prototype.stop = function() {
    clearTimeout(this.nextFrameTimer);
};

// Fetch-and-execute loop
// Will execute instructions for the duration of a frame
//
// The screen unit will notify the vblank period which
// is considered the end of a frame
//
// The function is called on a regular basis with a timeout
CPU.prototype.frame = function() {
    if (!this.isPaused) {
        this.nextFrameTimer = setTimeout(this.frame.bind(this), 1000 / GameboyJS.Screen.physics.FREQUENCY);
    }

    try {
        var vblank = false;
        while (!vblank) {
            var oldInstrCount = this.clock.c;
            if (!this.isHalted) {
                var opcode = this.fetchOpcode();
                GameboyJS.opcodeMap[opcode](this);
                this.r.F &= 0xF0; // tmp fix

                if (this.enableSerial) {
                    var instr = this.clock.c - oldInstrCount;
                    this.clock.serial += instr;
                    if (this.clock.serial >= 8 * this.SERIAL_INTERNAL_INSTR) {
                        this.endSerialTransfer();
                    }
                }
            } else {
                this.clock.c += 4;
            }

            var elapsed = this.clock.c - oldInstrCount;
            vblank = this.gpu.update(elapsed);
            this.timer.update(elapsed);
            this.input.update();
            this.apu.update(elapsed);
            this.checkInterrupt();
        }
        this.clock.c = 0;
    } catch (e) {
        this.gameboy.handleException(e);
    }
};

CPU.prototype.fetchOpcode = function() {
    var opcode = this.memory.rb(this.r.pc++);
    if (opcode === undefined) {console.log(opcode + ' at ' + (this.r.pc-1).toString(16));this.stop();return;}
    if (!GameboyJS.opcodeMap[opcode]) {
        console.error('Unknown opcode '+opcode.toString(16)+' at address '+(this.r.pc-1).toString(16)+', stopping execution...');
        this.stop();
        return null;
    }

    return opcode;
};

// read register
CPU.prototype.rr = function(register) {
    return this.r[register];
};

// write register
CPU.prototype.wr = function(register, value) {
    this.r[register] = value;
};

CPU.prototype.halt = function() {
    this.isHalted = true;
};
CPU.prototype.unhalt = function() {
    this.isHalted = false;
};
CPU.prototype.pause = function() {
    this.isPaused = true;
};
CPU.prototype.unpause = function() {
    if (this.isPaused) {
        this.isPaused = false;
        this.frame();
    }
};

// Look for interrupt flags
CPU.prototype.checkInterrupt = function() {
    if (!this.IME) {
        return;
    }
    for (var i = 0; i < 5; i++) {
        var IFval = this.memory.rb(0xFF0F);
        if (GameboyJS.Util.readBit(IFval, i) && this.isInterruptEnable(i)) {
            IFval &= (0xFF - (1<<i));
            this.memory.wb(0xFF0F, IFval);
            this.disableInterrupts();
            this.clock.c += 4; // 20 clocks to serve interrupt, with 16 for RSTn
            CPU.interruptRoutines[i](this);
            break;
        }
    }
};

// Set an interrupt flag
CPU.prototype.requestInterrupt = function(type) {
    var IFval = this.memory.rb(0xFF0F);
    IFval |= (1 << type)
    this.memory.wb(0xFF0F, IFval) ;
    this.unhalt();
};

CPU.prototype.isInterruptEnable = function(type) {
    return GameboyJS.Util.readBit(this.memory.rb(0xFFFF), type) != 0;
};

CPU.prototype.enableInterrupts = function() {
    this.IME = true;
};
CPU.prototype.disableInterrupts = function() {
    this.IME = false;
};

CPU.prototype.enableSerialTransfer = function() {
    this.enableSerial = 1;
    this.clock.serial = 0;
};

CPU.prototype.endSerialTransfer = function() {
    this.enableSerial = 0;
    var data = this.memory.rb(0xFF01);
    this.memory.wb(0xFF02, 0);
    this.serialHandler.out(data);
    this.memory.wb(0xFF01, this.serialHandler.in());
};

CPU.prototype.resetDivTimer = function() {
    this.timer.resetDiv();
};
GameboyJS.CPU = CPU;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

var Debug = {};
// Output a range of 16 memory addresses
Debug.view_memory = function(addr, gameboy) {
    var memory = gameboy.cpu.memory;
    addr = addr & 0xFFF0;
    var pad = '00';
    var str = addr.toString(16) + ':';
    for (var i = addr; i < addr + 0x10; i++) {
        if ((i & 0x1) == 0) {
            str += ' ';
        }
        var val = memory[i] || 0;

        val = val.toString(16);
        str += pad.substring(val.length) + val;
    }

    return str;
};

Debug.view_tile = function(gameboy, index, dataStart) {
    var memory = gameboy.cpu.memory;
    var screen = gameboy.screen;
    var LCDC = screen.deviceram(screen.LCDC);
    if (typeof dataStart === 'undefined') {
        dataStart = 0x8000;
        if (!GameboyJS.Util.readBit(LCDC, 4)) {
            dataStart = 0x8800;
            index = GameboyJS.cpuOps._getSignedValue(index) + 128;
        }
    }

    var tileData = screen.readTileData(index, dataStart);

    var pixelData = new Array(8 * 8)
    for (var line = 0; line < 8; line++) {
        var b1 = tileData.shift();
        var b2 = tileData.shift();

        for (var pixel = 0; pixel < 8; pixel++) {
            var mask = (1 << (7-pixel));
            var colorValue = ((b1 & mask) >> (7-pixel)) + ((b2 & mask) >> (7-pixel))*2;
            pixelData[line * 8 + pixel] = colorValue;
        }
    }

    var i = 0;
    while (pixelData.length) {
        console.log(i++ + ' ' + pixelData.splice(0, 8).join(''));
    }
};

Debug.list_visible_sprites = function(gameboy) {
    var memory = gameboy.cpu.memory;
    var indexes = new Array();
    for (var i = 0xFE00; i < 0xFE9F; i += 4) {
        var x = memory.oamram(i + 1);
        var y = memory.oamram(i);
        var tileIndex = memory.oamram(i + 2);
        if (x == 0 || x >= 168) {
            continue;
        }
        indexes.push({oamIndex:i, x:x, y:y, tileIndex:tileIndex});
    }

    return indexes;
};
GameboyJS.Debug = Debug;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";
var Screen;
var GPU = function(screen, cpu) {
    this.cpu = cpu;
    this.screen = screen;

    this.LCDC= 0xFF40;
    this.STAT= 0xFF41;
    this.SCY = 0xFF42;
    this.SCX = 0xFF43;
    this.LY  = 0xFF44;
    this.LYC = 0xFF45;
    this.BGP = 0xFF47;
    this.OBP0= 0xFF48;
    this.OBP1= 0xFF49;
    this.WY  = 0xFF4A;
    this.WX  = 0xFF4B;

    this.vram = cpu.memory.vram.bind(cpu.memory);

    this.OAM_START = 0xFE00;
    this.OAM_END   = 0xFE9F;
    this.deviceram = cpu.memory.deviceram.bind(cpu.memory);
    this.oamram = cpu.memory.oamram.bind(cpu.memory);
    this.VBLANK_TIME = 70224;
    this.clock = 0;
    this.mode = 2;
    this.line = 0;

    Screen = GameboyJS.Screen;
    this.buffer = new Array(Screen.physics.WIDTH * Screen.physics.HEIGHT);
    this.tileBuffer = new Array(8);
    this.bgTileCache = {};
};

GPU.tilemap = {
    HEIGHT: 32,
    WIDTH: 32,
    START_0: 0x9800,
    START_1: 0x9C00,
    LENGTH: 0x0400 // 1024 bytes = 32*32
};

GPU.prototype.update = function(clockElapsed) {
    this.clock += clockElapsed;
    var vblank = false;

    switch (this.mode) {
        case 0: // HBLANK
            if (this.clock >= 204) {
                this.clock -= 204;
                this.line++;
                this.updateLY();
                if (this.line == 144) {
                    this.setMode(1);
                    vblank = true;
                    this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.VBLANK);
                    this.drawFrame();
                } else {
                    this.setMode(2);
                }
            }
            break;
        case 1: // VBLANK
            if (this.clock >= 456) {
                this.clock -= 456;
                this.line++;
                if (this.line > 153) {
                    this.line = 0;
                    this.setMode(2);
                }
                this.updateLY();
            }

            break;
        case 2: // SCANLINE OAM
            if (this.clock >= 80) {
                this.clock -= 80;
                this.setMode(3);
            }
            break;
        case 3: // SCANLINE VRAM
            if (this.clock >= 172) {
                this.clock -= 172;
                this.drawScanLine(this.line);
                this.setMode(0);
            }
            break;
    }

    return vblank;
};

GPU.prototype.updateLY = function() {
    this.deviceram(this.LY, this.line);
    var STAT = this.deviceram(this.STAT);
    if (this.deviceram(this.LY) == this.deviceram(this.LYC)) {
        this.deviceram(this.STAT, STAT | (1 << 2));
        if (STAT & (1 << 6)) {
            this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.LCDC);
        }
    } else {
        this.deviceram(this.STAT, STAT & (0xFF - (1 << 2)));
    }
};

GPU.prototype.setMode = function(mode) {
    this.mode = mode;
    var newSTAT = this.deviceram(this.STAT);
    newSTAT &= 0xFC;
    newSTAT |= mode;
    this.deviceram(this.STAT, newSTAT);

    if (mode < 3) {
        if (newSTAT & (1 << (3+mode))) {
            this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.LCDC);
        }
    }
};

// Push one scanline into the main buffer
GPU.prototype.drawScanLine = function(line) {
    var LCDC = this.deviceram(this.LCDC);
    var enable = GameboyJS.Util.readBit(LCDC, 7);
    if (enable) {
        var lineBuffer = new Array(Screen.physics.WIDTH);
        this.drawBackground(LCDC, line, lineBuffer);
        this.drawSprites(LCDC, line, lineBuffer);
        // TODO draw a line for the window here too
    }
};

GPU.prototype.drawFrame = function() {
    var LCDC = this.deviceram(this.LCDC);
    var enable = GameboyJS.Util.readBit(LCDC, 7);
    if (enable) {
        //this.drawSprites(LCDC);
        this.drawWindow(LCDC);
    }
    this.bgTileCache = {};
    this.screen.render(this.buffer);
};

GPU.prototype.drawBackground = function(LCDC, line, lineBuffer) {
    if (!GameboyJS.Util.readBit(LCDC, 0)) {
        return;
    }

    var mapStart = GameboyJS.Util.readBit(LCDC, 3) ? GPU.tilemap.START_1 : GPU.tilemap.START_0;

    var dataStart, signedIndex = false;
    if (GameboyJS.Util.readBit(LCDC, 4)) {
        dataStart = 0x8000;
    } else {
        dataStart = 0x8800;
        signedIndex = true;
    }

    var bgx = this.deviceram(this.SCX);
    var bgy = this.deviceram(this.SCY);
    var tileLine = ((line + bgy) & 7);

    // browse BG tilemap for the line to render
    var tileRow = ((((bgy + line) / 8) | 0) & 0x1F);
    var firstTile = ((bgx / 8) | 0) + 32 * tileRow;
    var lastTile = firstTile + Screen.physics.WIDTH / 8 + 1;
    if ((lastTile & 0x1F) < (firstTile & 0x1F)) {
        lastTile -= 32;
    }
    var x = (firstTile & 0x1F) * 8 - bgx; // x position of the first tile's leftmost pixel
    for (var i = firstTile; i != lastTile; i++, (i & 0x1F) == 0 ? i-=32 : null) {
        var tileIndex = this.vram(i + mapStart);

        if (signedIndex) {
            tileIndex = GameboyJS.Util.getSignedValue(tileIndex) + 128;
        }

        // try to retrieve the tile data from the cache, or use readTileData() to read from ram
        // TODO find a better cache system now that the BG is rendered line by line
        var tileData = this.bgTileCache[tileIndex] || (this.bgTileCache[tileIndex] = this.readTileData(tileIndex, dataStart));

        this.drawTileLine(tileData, tileLine);
        this.copyBGTileLine(lineBuffer, this.tileBuffer, x);
        x += 8;
    }

    this.copyLineToBuffer(lineBuffer, line);
};

// Copy a tile line from a tileBuffer to a line buffer, at a given x position
GPU.prototype.copyBGTileLine = function(lineBuffer, tileBuffer, x) {
    // copy tile line to buffer
    for (var k = 0; k < 8; k++, x++) {
        if (x < 0 || x >= Screen.physics.WIDTH) continue;
        lineBuffer[x] = tileBuffer[k];
    }
};

// Copy a scanline into the main buffer
GPU.prototype.copyLineToBuffer = function(lineBuffer, line) {
    var bgPalette = GPU.getPalette(this.deviceram(this.BGP));

    for (var x = 0; x < Screen.physics.WIDTH; x++) {
        var color = lineBuffer[x];
        this.drawPixel(x, line, bgPalette[color]);
    }
};

// Write a line of a tile (8 pixels) into a buffer array
GPU.prototype.drawTileLine = function(tileData, line, xflip, yflip) {
    xflip = xflip | 0;
    yflip = yflip | 0;
    var l = yflip ? 7 - line : line;
    var byteIndex = l * 2;
    var b1 = tileData[byteIndex++];
    var b2 = tileData[byteIndex++];

    var offset = 8;
    for (var pixel = 0; pixel < 8; pixel++) {
        offset--;
        var mask = (1 << offset);
        var colorValue = ((b1 & mask) >> offset) + ((b2 & mask) >> offset)*2;
        var p = xflip ? offset : pixel;
        this.tileBuffer[p] = colorValue;
    }
};

GPU.prototype.drawSprites = function(LCDC, line, lineBuffer) {
    if (!GameboyJS.Util.readBit(LCDC, 1)) {
        return;
    }
    var spriteHeight = GameboyJS.Util.readBit(LCDC, 2) ? 16 : 8;

    var sprites = new Array();
    for (var i = this.OAM_START; i < this.OAM_END && sprites.length < 10; i += 4) {
        var y = this.oamram(i);
        var x = this.oamram(i+1);
        var index = this.oamram(i+2);
        var flags = this.oamram(i+3);

        if (y - 16 > line || y - 16 < line - spriteHeight) {
            continue;
        }
        sprites.push({x:x, y:y, index:index, flags:flags})
    }

    if (sprites.length == 0) return;

    // cache object to store read tiles from this frame
    var cacheTile = {};
    var spriteLineBuffer = new Array(Screen.physics.WIDTH);

    for (var i = 0; i < sprites.length; i++) {
        var sprite = sprites[i];
        var tileLine = line - sprite.y + 16;
        var paletteNumber = GameboyJS.Util.readBit(flags, 4);
        var xflip = GameboyJS.Util.readBit(sprite.flags, 5);
        var yflip = GameboyJS.Util.readBit(sprite.flags, 6);
        var tileData = cacheTile[sprite.index] || (cacheTile[sprite.index] = this.readTileData(sprite.index, 0x8000, spriteHeight * 2));
        this.drawTileLine(tileData, tileLine, xflip, yflip);
        this.copySpriteTileLine(spriteLineBuffer, this.tileBuffer, sprite.x - 8, paletteNumber);
    }

    this.copySpriteLineToBuffer(spriteLineBuffer, line);
};

// Copy a tile line from a tileBuffer to a line buffer, at a given x position
GPU.prototype.copySpriteTileLine = function(lineBuffer, tileBuffer, x, palette) {
    // copy tile line to buffer
    for (var k = 0; k < 8; k++, x++) {
        if (x < 0 || x >= Screen.physics.WIDTH || tileBuffer[k] == 0) continue;
        lineBuffer[x] = {color:tileBuffer[k], palette: palette};
    }
};

// Copy a sprite scanline into the main buffer
GPU.prototype.copySpriteLineToBuffer = function(spriteLineBuffer, line) {
    var spritePalettes = {};
    spritePalettes[0] = GPU.getPalette(this.deviceram(this.OBP0));
    spritePalettes[1] = GPU.getPalette(this.deviceram(this.OBP1));

    for (var x = 0; x < Screen.physics.WIDTH; x++) {
        if (!spriteLineBuffer[x]) continue;
        var color = spriteLineBuffer[x].color;
        if (color === 0) continue;
        var paletteNumber = spriteLineBuffer[x].palette;
        this.drawPixel(x, line, spritePalettes[paletteNumber][color]);
    }
};

GPU.prototype.drawTile = function(tileData, x, y, buffer, bufferWidth, xflip, yflip, spriteMode) {
    xflip = xflip | 0;
    yflip = yflip | 0;
    spriteMode = spriteMode | 0;
    var byteIndex = 0;
    for (var line = 0; line < 8; line++) {
        var l = yflip ? 7 - line : line;
        var b1 = tileData[byteIndex++];
        var b2 = tileData[byteIndex++];

        for (var pixel = 0; pixel < 8; pixel++) {
            var mask = (1 << (7-pixel));
            var colorValue = ((b1 & mask) >> (7-pixel)) + ((b2 & mask) >> (7-pixel))*2;
            if (spriteMode && colorValue == 0) continue;
            var p = xflip ? 7 - pixel : pixel;
            var bufferIndex = (x + p) + (y + l) * bufferWidth;
            buffer[bufferIndex] = colorValue;
        }
    }
};

// get an array of tile bytes data (16 entries for 8*8px)
GPU.prototype.readTileData = function(tileIndex, dataStart, tileSize) {
    tileSize = tileSize || 0x10; // 16 bytes / tile by default (8*8 px)
    var tileData = new Array();

    var tileAddressStart = dataStart + (tileIndex * 0x10);
    for (var i = tileAddressStart; i < tileAddressStart + tileSize; i++) {
        tileData.push(this.vram(i));
    }

    return tileData;
};

GPU.prototype.drawWindow = function(LCDC) {
    if (!GameboyJS.Util.readBit(LCDC, 5)) {
        return;
    }

    var buffer = new Array(256*256);
    var mapStart = GameboyJS.Util.readBit(LCDC, 6) ? GPU.tilemap.START_1 : GPU.tilemap.START_0;

    var dataStart, signedIndex = false;
    if (GameboyJS.Util.readBit(LCDC, 4)) {
        dataStart = 0x8000;
    } else {
        dataStart = 0x8800;
        signedIndex = true;
    }

    // browse Window tilemap
    for (var i = 0; i < GPU.tilemap.LENGTH; i++) {
        var tileIndex = this.vram(i + mapStart);

        if (signedIndex) {
            tileIndex = GameboyJS.Util.getSignedValue(tileIndex) + 128;
        }

        var tileData = this.readTileData(tileIndex, dataStart);
        var x = i % GPU.tilemap.WIDTH;
        var y = (i / GPU.tilemap.WIDTH) | 0;
        this.drawTile(tileData, x * 8, y * 8, buffer, 256);
    }

    var wx = this.deviceram(this.WX) - 7;
    var wy = this.deviceram(this.WY);
    for (var x = Math.max(0, -wx); x < Math.min(Screen.physics.WIDTH, Screen.physics.WIDTH - wx); x++) {
        for (var y = Math.max(0, -wy); y < Math.min(Screen.physics.HEIGHT, Screen.physics.HEIGHT - wy); y++) {
            var color = buffer[(x & 255) + (y & 255) * 256];
            this.drawPixel(x + wx, y + wy, color);
        }
    }
};

GPU.prototype.drawPixel = function(x, y, color) {
    this.buffer[y * 160 + x] = color;
};

GPU.prototype.getPixel = function(x, y) {
    return this.buffer[y * 160 + x];
};

// Get the palette mapping from a given palette byte as stored in memory
// A palette will map a tile color to a final palette color index
// used with Screen.colors to get a shade of grey
GPU.getPalette = function(paletteByte) {
    var palette = [];
    for (var i = 0; i < 8; i += 2) {
        var shade = (paletteByte & (3 << i)) >> i;
        palette.push(shade);
    }
    return palette;
};

GameboyJS.GPU = GPU;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// Screen device
var Screen = function(canvas, pixelSize) {
    this.context = canvas.getContext('2d');
    this.canvas = canvas;
    this.pixelSize = pixelSize || 1;
    this.initImageData();
};

Screen.colors = [
    0xFF,
    0xAA,
    0x55,
    0x00
];

Screen.physics = {
    WIDTH    : 160,
    HEIGHT   : 144,
    FREQUENCY: 60
};

Screen.prototype.setPixelSize = function(pixelSize) {
    this.pixelSize = pixelSize;
    this.initImageData();
};

Screen.prototype.initImageData = function() {
    this.canvas.width = Screen.physics.WIDTH * this.pixelSize;
    this.canvas.height = Screen.physics.HEIGHT * this.pixelSize;
    this.imageData = this.context.createImageData(this.canvas.width, this.canvas.height);
};

Screen.prototype.clearScreen = function() {
    this.context.fillStyle = '#FFF';
    this.context.fillRect(0, 0, Screen.physics.WIDTH * this.pixelSize, Screen.physics.HEIGHT * this.pixelSize);
};

Screen.prototype.fillImageData = function(buffer) {
    for (var y = 0; y < Screen.physics.HEIGHT; y++) {
        for (var py = 0; py < this.pixelSize; py++) {
            var _y = y * this.pixelSize + py;
            for (var x = 0; x < Screen.physics.WIDTH; x++) {
                for (var px = 0; px < this.pixelSize; px++) {
                    var offset = _y * this.canvas.width + (x * this.pixelSize + px);
                    var v = Screen.colors[buffer[y * Screen.physics.WIDTH + x]];
                    this.imageData.data[offset * 4] = v;
                    this.imageData.data[offset * 4 + 1] = v;
                    this.imageData.data[offset * 4 + 2] = v;
                    this.imageData.data[offset * 4 + 3] = 255;
                }
            }
        }
    }
};

Screen.prototype.render = function(buffer) {
    this.fillImageData(buffer);
    this.context.putImageData(this.imageData, 0, 0);
};

GameboyJS.Screen = Screen;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// This exception should be thrown whenever a critical feature that
// has not been implemented is requested
function UnimplementedException(message, fatal) {
    this.message = message;
    this.name = UnimplementedException;
    if (fatal === undefined) {
        fatal = true;
    }
    this.fatal = fatal;
}
GameboyJS.UnimplementedException = UnimplementedException;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// Object for mapping the cartridge RAM
var ExtRam = function() {
    this.extRam = null;
    this.ramSize = 0;
    this.ramBank = 0;
};

ExtRam.prototype.loadRam = function(game, size) {
    this.gameName = game;

    this.ramSize = size;
    this.ramBanksize = this.ramSize >= 0x2000 ? 8192 : 2048;

    var key = this.getStorageKey();
    var data = localStorage.getItem(key);
    if (data == null) {
        this.extRam = Array.apply(null, new Array(this.ramSize)).map(function(){return 0;});
    } else {
        this.extRam = JSON.parse(data);
        if (this.extRam.length != size) {
            console.error('Found RAM data but not matching expected size.');
        }
    }
};

ExtRam.prototype.setRamBank = function(bank) {
    this.ramBank = bank;
};

ExtRam.prototype.manageWrite = function(offset, value) {
    this.extRam[this.ramBank * 8192 + offset] = value;
};

ExtRam.prototype.manageRead = function(offset) {
    return this.extRam[this.ramBank * 8192 + offset];
};

ExtRam.prototype.getStorageKey = function() {
    return this.gameName + '_EXTRAM';;
};
// Actually save the RAM in the physical storage (localStorage)
ExtRam.prototype.saveRamData = function() {
    localStorage.setItem(this.getStorageKey(), JSON.stringify(this.extRam));
};
GameboyJS.ExtRam = ExtRam;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// This is the default buttons mapping for the Gamepad
// It's optimized for the XBOX pad
//
// Any other mapping can be provided as a constructor argument of the Gamepad object
// An alternative mapping should be an object with keys being the indexes
// of the gamepad buttons and values the normalized gameboy button names
var xboxMapping = {
    0: 'UP',
    1: 'DOWN',
    2: 'LEFT',
    3: 'RIGHT',
    4: 'START',
    5: 'SELECT',
    11: 'A',
    12: 'B'
};

// Gamepad listener
// Communication layer between the Gamepad API and the Input class
// Any physical controller can be used but the mapping should be provided
// in order to get an optimal layout of the buttons (see above)
var Gamepad = function(mapping) {
    this.gamepad = null;
    this.state = {A:0,B:0,START:0,SELECT:0,LEFT:0,RIGHT:0,UP:0,DOWN:0};
    this.pullInterval = null;
    this.buttonMapping = mapping || xboxMapping;
};

// Initialize the keyboard listeners and set up the callbacks
// for button press / release
Gamepad.prototype.init = function(onPress, onRelease) {
    this.onPress = onPress;
    this.onRelease = onRelease;

    var self = this;
    window.addEventListener('gamepadconnected', function(e) {
        self.gamepad = e.gamepad;
        self.activatePull();
    });
    window.addEventListener('gamepaddisconnected', function(e) {
        self.gamepad = null;
        self.deactivatePull();
    });
};

Gamepad.prototype.activatePull = function() {
    this.deactivatePull();
    this.pullInterval = setInterval(this.pullState.bind(this), 100);
};

Gamepad.prototype.deactivatePull = function() {
    clearInterval(this.pullInterval);
};

// Check the state of the current gamepad in order to detect any press/release action
Gamepad.prototype.pullState = function() {
    for (var index in this.buttonMapping) {
        var button = this.buttonMapping[index];
        var oldState = this.state[button];
        this.state[button] = this.gamepad.buttons[index].pressed;

        if (this.state[button] == 1 && oldState == 0) {
            this.managePress(button);
        } else if (this.state[button] == 0 && oldState == 1) {
            this.manageRelease(button);
        }
    }
};

Gamepad.prototype.managePress = function(key) {
    this.onPress(key);
};

Gamepad.prototype.manageRelease = function(key) {
    this.onRelease(key);
};

GameboyJS.Gamepad = Gamepad;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// The Input management system
//
// The pressKey() and releaseKey() functions should be called by a device class
// like GameboyJS.Keyboard after a physical button trigger event
//
// They rely on the name of the original buttons as parameters (see Input.keys)
var Input = function(cpu, pad) {
    this.cpu = cpu;
    this.memory = cpu.memory;
    this.P1 = 0xFF00;
    this.state = 0;

    pad.init(this.pressKey.bind(this), this.releaseKey.bind(this));
};

Input.keys = {
    START:  0x80,
    SELECT: 0x40,
    B:      0x20,
    A:      0x10,
    DOWN:   0x08,
    UP:     0x04,
    LEFT:   0x02,
    RIGHT:  0x01
};

Input.prototype.pressKey = function(key) {
    this.state |= Input.keys[key];

    this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.HILO);
};

Input.prototype.releaseKey = function(key) {
    var mask = 0xFF - Input.keys[key];
    this.state &= mask;
};

Input.prototype.update = function() {
    var value = this.memory.rb(this.P1);
    value = ((~value) & 0x30); // invert the value so 1 means 'active'
    if (value & 0x10) { // direction keys listened
        value |= (this.state & 0x0F);
    } else if (value & 0x20) { // action keys listened
        value |= ((this.state & 0xF0) >> 4);
    } else if ((value & 0x30) == 0) { // no keys listened
        value &= 0xF0;
    }

    value = ((~value) & 0x3F); // invert back
    this.memory[this.P1] = value;
};
GameboyJS.Input = Input;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// Keyboard listener
// Does the mapping between the keyboard and the Input class
var Keyboard = function() {};

// Initialize the keyboard listeners and set up the callbacks
// for button press / release
Keyboard.prototype.init = function(onPress, onRelease) {
    this.onPress = onPress;
    this.onRelease = onRelease;

    var self = this;
    document.addEventListener('keydown', function(e) {
        self.managePress(e.keyCode);
    });
    document.addEventListener('keyup', function(e) {
        self.manageRelease(e.keyCode);
    });
}

Keyboard.prototype.managePress = function(keycode) {
    var key = this.translateKey(keycode);
    if (key) {
        this.onPress(key);
    }
};

Keyboard.prototype.manageRelease = function(keycode) {
    var key = this.translateKey(keycode);
    if (key) {
        this.onRelease(key);
    }
};

// Transform a keyboard keycode into a key of the Input.keys object
Keyboard.prototype.translateKey = function(keycode) {
    var key = null;
    switch (keycode) {
        case 71: // G
            key = 'A';
            break;
        case 66: // B
            key = 'B';
            break;
        case 72: // H
            key = 'START';
            break;
        case 78: // N
            key = 'SELECT';
            break;
        case 37: // left
            key = 'LEFT';
            break;
        case 38: // up
            key = 'UP';
            break;
        case 39: // right
            key = 'RIGHT';
            break;
        case 40: // down
            key = 'DOWN';
            break;
    }

    return key;
};
GameboyJS.Keyboard = Keyboard;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// List of CPU operations
// Most operations have been factorized here to limit code redundancy
//
// How to read operations:
// Uppercase letters qualify the kind of operation (LD = LOAD, INC = INCREMENT, etc.)
// Lowercase letters are used to hint parameters :
// r = register, n = 1 memory byte, sp = sp register,
// a = suffix for memory address, i = bit index
// Example : LDrrar = LOAD operation with two-registers memory address
// as first parameter and one register value as second
//
// Underscore-prefixed functions are here to delegate the logic between similar operations,
// they should not be called from outside
//
// It's up to each operation to update the CPU clock
var ops = {
    LDrrnn: function(p, r1, r2) {p.wr(r2, p.memory.rb(p.r.pc));p.wr(r1, p.memory.rb(p.r.pc+1)); p.r.pc+=2;p.clock.c += 12;},
    LDrrar: function(p, r1, r2, r3) {ops._LDav(p, GameboyJS.Util.getRegAddr(p, r1, r2), p.r[r3]);p.clock.c += 8;},
    LDrrra: function(p, r1, r2, r3) {p.wr(r1, p.memory.rb(GameboyJS.Util.getRegAddr(p, r2, r3)));p.clock.c += 8;},
    LDrn:   function(p, r1) {p.wr(r1, p.memory.rb(p.r.pc++));p.clock.c += 8;},
    LDrr:   function(p, r1, r2) {p.wr(r1, p.r[r2]);p.clock.c += 4;},
    LDrar:  function(p, r1, r2) {p.memory.wb(p.r[r1]+0xFF00, p.r[r2]);p.clock.c += 8;},
    LDrra:  function(p, r1, r2) {p.wr(r1, p.memory.rb(p.r[r2]+0xFF00));p.clock.c += 8;},
    LDspnn: function(p) {p.wr('sp', (p.memory.rb(p.r.pc + 1) << 8) + p.memory.rb(p.r.pc));p.r.pc+=2;p.clock.c += 12;},
    LDsprr: function(p, r1, r2) {p.wr('sp', GameboyJS.Util.getRegAddr(p, r1, r2));p.clock.c += 8;},
    LDnnar: function(p, r1) {var addr=(p.memory.rb(p.r.pc + 1) << 8) + p.memory.rb(p.r.pc);p.memory.wb(addr,p.r[r1]);p.r.pc+=2; p.clock.c += 16;},
    LDrnna: function(p, r1) {var addr=(p.memory.rb(p.r.pc + 1) << 8) + p.memory.rb(p.r.pc);p.wr(r1, p.memory.rb(addr));p.r.pc+=2; p.clock.c += 16;},
    LDrrspn:function(p, r1, r2) {var rel = p.memory.rb(p.r.pc++);rel=GameboyJS.Util.getSignedValue(rel);var val=p.r.sp + rel;
        var c = (p.r.sp&0xFF) + (rel&0xFF) > 0xFF;var h = (p.r.sp & 0xF) + (rel & 0xF) > 0xF;val &= 0xFFFF;
        var f = 0; if(h)f|=0x20;if(c)f|=0x10;p.wr('F', f);
        p.wr(r1, val >> 8);p.wr(r2, val&0xFF);
        p.clock.c+=12;},
    LDnnsp: function(p) {var addr = p.memory.rb(p.r.pc++) + (p.memory.rb(p.r.pc++)<<8); ops._LDav(p, addr, p.r.sp & 0xFF);ops._LDav(p, addr+1, p.r.sp >> 8);p.clock.c+=20;},
    LDrran: function(p, r1, r2){var addr = GameboyJS.Util.getRegAddr(p, r1, r2);ops._LDav(p, addr, p.memory.rb(p.r.pc++));p.clock.c+=12;},
    _LDav:  function(p, addr, val){p.memory.wb(addr, val);},
    LDHnar: function(p, r1){p.memory.wb(0xFF00 + p.memory.rb(p.r.pc++), p.r[r1]);p.clock.c+=12;},
    LDHrna: function(p, r1){p.wr(r1, p.memory.rb(0xFF00 + p.memory.rb(p.r.pc++)));p.clock.c+=12;},
    INCrr:  function(p, r1, r2) {p.wr(r2, (p.r[r2]+1)&0xFF); if (p.r[r2] == 0) p.wr(r1, (p.r[r1]+1)&0xFF);p.clock.c += 8;},
    INCrra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var val = (p.memory.rb(addr)+1)&0xFF;var z = val==0;var h=(p.memory.rb(addr)&0xF)+1 > 0xF;
        p.memory.wb(addr, val);
        p.r.F&=0x10;if(h)p.r.F|=0x20;if(z)p.r.F|=0x80;
        p.clock.c+=12;},
    INCsp:  function(p){p.wr('sp', p.r.sp+1); p.r.sp &= 0xFFFF; p.clock.c+=8;},
    INCr:   function(p, r1) {var h = ((p.r[r1]&0xF) + 1)&0x10;p.wr(r1, (p.r[r1] + 1)&0xFF);var z = p.r[r1]==0;
        p.r.F&=0x10;if(h)p.r.F|=0x20;if(z)p.r.F|=0x80;
        p.clock.c += 4;},
    DECrr:  function(p, r1, r2) {p.wr(r2, (p.r[r2] - 1) & 0xFF); if (p.r[r2] == 0xFF) p.wr(r1, (p.r[r1] - 1)&0xFF);p.clock.c += 8;},
    DECsp:  function(p){p.wr('sp', p.r.sp-1); p.r.sp &= 0xFFFF; p.clock.c+=8;},
    DECr:   function(p, r1) {var h = (p.r[r1]&0xF) < 1;p.wr(r1, (p.r[r1] - 1) & 0xFF);var z = p.r[r1]==0;
        p.r.F&=0x10;p.r.F|=0x40;if(h)p.r.F|=0x20;if(z)p.r.F|=0x80;
        p.clock.c += 4;},
    DECrra: function(p, r1, r2){var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var val = (p.memory.rb(addr)-1)&0xFF;var z = val==0;var h=(p.memory.rb(addr)&0xF) < 1;
        p.memory.wb(addr, val);
        p.r.F&=0x10;p.r.F|=0x40;if(h)p.r.F|=0x20;if(z)p.r.F|=0x80;
        p.clock.c+=12;},
    ADDrr:  function(p, r1, r2) {var n = p.r[r2];ops._ADDrn(p, r1, n); p.clock.c += 4;},
    ADDrn:  function(p, r1) {var n = p.memory.rb(p.r.pc++);ops._ADDrn(p, r1, n); p.clock.c+=8;},
    _ADDrn: function(p, r1, n) {var h=((p.r[r1]&0xF)+(n&0xF))&0x10;p.wr(r1, p.r[r1]+n);var c=p.r[r1]&0x100;p.r[r1]&=0xFF;
            var f = 0;if (p.r[r1]==0)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.wr('F', f);},
    ADDrrrr:function(p, r1, r2, r3, r4) {ops._ADDrrn(p, r1, r2, (p.r[r3]<<8) + p.r[r4]); p.clock.c+=8;},
    ADDrrsp:function(p, r1, r2) {ops._ADDrrn(p, r1, r2, p.r.sp); p.clock.c += 8;},
    ADDspn: function(p) {var v = p.memory.rb(p.r.pc++);v = GameboyJS.Util.getSignedValue(v);
        var c = ((p.r.sp&0xFF) + (v&0xFF)) > 0xFF; var h = (p.r.sp & 0xF) + (v&0xF) > 0xF;
        var f = 0; if(h)f|=0x20;if(c)f|=0x10;p.wr('F', f);
        p.wr('sp', (p.r.sp + v) & 0xFFFF);
        p.clock.c+=16;},
    _ADDrrn:function(p, r1, r2, n) {var v1 = (p.r[r1]<<8) + p.r[r2];var v2 = n;
        var res = v1 + v2;var c = res&0x10000;var h = ((v1&0xFFF) + (v2&0xFFF))&0x1000;var z = p.r.F&0x80;
        res&=0xFFFF;p.r[r2]=res&0xFF;res=res>>8;p.r[r1]=res&0xFF;
        var f=0;if(z)f|=0x80;if(h)f|=0x20;if(c)f|=0x10;p.r.F=f;},
    ADCrr:  function(p, r1, r2) {var n = p.r[r2]; ops._ADCrn(p, r1, n); p.clock.c += 4;},
    ADCrn:  function(p, r1) {var n = p.memory.rb(p.r.pc++); ops._ADCrn(p, r1, n); p.clock.c += 8;},
    _ADCrn: function(p, r1, n) {
        var c = p.r.F&0x10?1:0;var h=((p.r[r1]&0xF)+(n&0xF)+c)&0x10;
        p.wr(r1, p.r[r1]+n+c);c=p.r[r1]&0x100;p.r[r1]&=0xFF;
        var f = 0;if (p.r[r1]==0)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.r.F=f;},
    ADCrrra:function(p, r1, r2, r3) {var n = p.memory.rb(GameboyJS.Util.getRegAddr(p, r2, r3)); ops._ADCrn(p, r1, n); p.clock.c += 8;},
    ADDrrra:function(p, r1, r2, r3) {var v = p.memory.rb(GameboyJS.Util.getRegAddr(p, r2, r3));var h=((p.r[r1]&0xF)+(v&0xF))&0x10;p.wr(r1, p.r[r1]+v);var c=p.r[r1]&0x100;p.r[r1]&=0xFF;
        var f = 0;if (p.r[r1]==0)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.wr('F', f);
        p.clock.c += 8;},
    SUBr:   function(p, r1) {var n = p.r[r1];ops._SUBn(p, n);p.clock.c += 4;},
    SUBn:   function(p) {var n = p.memory.rb(p.r.pc++);ops._SUBn(p, n);p.clock.c += 8;},
    SUBrra: function(p, r1, r2) {var n = p.memory.rb(GameboyJS.Util.getRegAddr(p, r1, r2));ops._SUBn(p, n);p.clock.c+=8;},
    _SUBn:  function(p, n) {var c = p.r.A < n;var h = (p.r.A&0xF) < (n&0xF);
        p.wr('A', p.r.A - n);p.r.A&=0xFF; var z = p.r.A==0;
        var f = 0x40;if (z)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.wr('F', f);},
    SBCn:   function(p) {var n = p.memory.rb(p.r.pc++); ops._SBCn(p, n); p.clock.c += 8;},
    SBCr:   function(p, r1) {var n = p.r[r1]; ops._SBCn(p, n); p.clock.c += 4;},
    SBCrra: function(p, r1, r2) {var v = p.memory.rb((p.r[r1] << 8) + p.r[r2]); ops._SBCn(p, v); p.clock.c += 8;},
    _SBCn:  function(p, n) {var carry = p.r.F&0x10 ? 1 : 0;
        var c = p.r.A < n + carry;var h = (p.r.A&0xF) < (n&0xF) + carry;
        p.wr('A', p.r.A - n - carry); p.r.A&=0xFF; var z = p.r.A == 0;
        var f = 0x40;if (z)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.r.F=f;},
    ORr:    function(p, r1) {p.r.A|=p.r[r1];p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 4;},
    ORn:    function(p) {p.r.A|=p.memory.rb(p.r.pc++);p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 8;},
    ORrra:  function(p, r1, r2) {p.r.A|=p.memory.rb((p.r[r1] << 8)+ p.r[r2]);p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 8;},
    ANDr:   function(p, r1) {p.r.A&=p.r[r1];p.r.F=(p.r.A==0)?0xA0:0x20;p.clock.c += 4;},
    ANDn:   function(p) {p.r.A&=p.memory.rb(p.r.pc++);p.r.F=(p.r.A==0)?0xA0:0x20;p.clock.c += 8;},
    ANDrra: function(p, r1, r2) {p.r.A&=p.memory.rb(GameboyJS.Util.getRegAddr(p, r1, r2));p.r.F=(p.r.A==0)?0xA0:0x20;p.clock.c += 8;},
    XORr:   function(p, r1) {p.r.A^=p.r[r1];p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 4;},
    XORn:   function(p) {p.r.A^=p.memory.rb(p.r.pc++);p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 8;},
    XORrra: function(p, r1, r2) {p.r.A^=p.memory.rb((p.r[r1] << 8)+ p.r[r2]);p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 8;},
    CPr:    function(p, r1) {var n = p.r[r1];ops._CPn(p, n); p.clock.c += 4;},
    CPn:    function(p) {var n =p.memory.rb(p.r.pc++);ops._CPn(p, n);p.clock.c+=8;},
    CPrra:  function(p, r1, r2) {var n = p.memory.rb(GameboyJS.Util.getRegAddr(p, r1, r2));ops._CPn(p, n);p.clock.c+=8;},
    _CPn:   function(p, n) {
        var c = p.r.A < n;var z = p.r.A == n;var h = (p.r.A&0xF) < (n&0xF);
        var f = 0x40;if(z)f+=0x80;if (h)f+=0x20;if (c)f+=0x10;p.r.F=f;},
    RRCr:   function(p, r1) {p.r.F=0;var out=p.r[r1] & 0x01;if(out)p.r.F|=0x10;p.r[r1]=(p.r[r1]>>1)|(out*0x80);if(p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    RRCrra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F=0;var out=p.memory.rb(addr)&0x01;if(out)p.r.F|=0x10;p.memory.wb(addr, (p.memory.rb(addr)>>1)|(out*0x80));if(p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    RLCr:   function(p, r1) {p.r.F=0;var out=p.r[r1]&0x80?1:0;if(out)p.r.F|=0x10;p.r[r1]=((p.r[r1]<<1)+out)&0xFF;if(p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    RLCrra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F=0;var out=p.memory.rb(addr)&0x80?1:0;if(out)p.r.F|=0x10;p.memory.wb(addr, ((p.memory.rb(addr)<<1)+out)&0xFF);if(p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    RLr:    function(p, r1) {var c=(p.r.F&0x10)?1:0;p.r.F=0;var out=p.r[r1]&0x80;out?p.r.F|=0x10:p.r.F&=0xEF;p.r[r1]=((p.r[r1]<<1)+c)&0xFF;if(p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    RLrra:  function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var c=(p.r.F&0x10)?1:0;p.r.F=0;var out=p.memory.rb(addr)&0x80;out?p.r.F|=0x10:p.r.F&=0xEF;p.memory.wb(addr,((p.memory.rb(addr)<<1)+c)&0xFF);if(p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    RRr:    function(p, r1) {var c=(p.r.F&0x10)?1:0;p.r.F=0;var out=p.r[r1]&0x01;out?p.r.F|=0x10:p.r.F&=0xEF;p.r[r1]=(p.r[r1]>>1)|(c*0x80);if(p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    RRrra:  function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var c=(p.r.F&0x10)?1:0;p.r.F=0;var out=p.memory.rb(addr)&0x01;out?p.r.F|=0x10:p.r.F&=0xEF;p.memory.wb(addr,(p.memory.rb(addr)>>1)|(c*0x80));if(p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    SRAr:   function(p, r1) {p.r.F = 0;if (p.r[r1]&0x01)p.r.F|=0x10;var msb=p.r[r1]&0x80;p.r[r1]=(p.r[r1]>>1)|msb;if (p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    SRArra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F = 0;if (p.memory.rb(addr)&0x01)p.r.F|=0x10;var msb=p.memory.rb(addr)&0x80;p.memory.wb(addr, (p.memory.rb(addr)>>1)|msb);if (p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    SLAr:   function(p, r1) {p.r.F = 0;if (p.r[r1]&0x80)p.r.F|=0x10;p.r[r1]=(p.r[r1]<<1)&0xFF;if (p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    SLArra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F = 0;if (p.memory.rb(addr)&0x80)p.r.F|=0x10;p.memory.wb(addr, (p.memory.rb(addr)<<1)&0xFF);if (p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    SRLr:   function(p, r1) {p.r.F = 0;if (p.r[r1]&0x01)p.r.F|=0x10;p.r[r1]=p.r[r1]>>1;if (p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    SRLrra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F = 0;if (p.memory.rb(addr)&0x01)p.r.F|=0x10;p.memory.wb(addr, p.memory.rb(addr)>>1);if (p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    BITir:  function(p, i, r1) {var mask=1<<i;var z=(p.r[r1]&mask)?0:1;var f=p.r.F&0x10;f |= 0x20;if(z)f|=0x80;p.r.F=f;p.clock.c+=4;},
    BITirra:function(p, i, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var mask=1<<i;var z=(p.memory.rb(addr)&mask)?0:1;var f=p.r.F&0x10;f |= 0x20;if(z)f|=0x80;p.r.F=f;p.clock.c+=8;},
    SETir:  function(p, i, r1) {var mask=1<<i;p.r[r1]|=mask;p.clock.c += 4;},
    SETirra:function(p, i, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var mask=1<<i;p.memory.wb(addr, p.memory.rb(addr)|mask);p.clock.c += 12;},
    RESir:  function(p, i, r1) {var mask=0xFF - (1<<i);p.r[r1]&=mask;p.clock.c += 4;},
    RESirra:function(p, i, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var mask=0xFF - (1<<i);p.memory.wb(addr, p.memory.rb(addr)&mask);p.clock.c += 12;},
    SWAPr:  function(p, r1) {p.r[r1] = ops._SWAPn(p, p.r[r1]);p.clock.c+=4;},
    SWAPrra:function(p, r1, r2){var addr = (p.r[r1] << 8)+ p.r[r2]; p.memory.wb(addr, ops._SWAPn(p, p.memory.rb(addr))); p.clock.c+=12;},
    _SWAPn: function(p, n){p.r.F = n==0?0x80:0;return ((n&0xF0) >> 4) | ((n&0x0F) << 4);},
    JPnn:   function(p) {p.wr('pc', (p.memory.rb(p.r.pc+1) << 8) + p.memory.rb(p.r.pc));p.clock.c += 16;},
    JRccn:  function(p, cc) {if (GameboyJS.Util.testFlag(p, cc)){var v=p.memory.rb(p.r.pc++);v=GameboyJS.Util.getSignedValue(v);p.r.pc += v;p.clock.c+=4;}else{p.r.pc++;}p.clock.c += 8;},
    JPccnn: function(p, cc) {if (GameboyJS.Util.testFlag(p, cc)){p.wr('pc', (p.memory.rb(p.r.pc+1) << 8) + p.memory.rb(p.r.pc));p.clock.c+=4;}else{p.r.pc+=2;}p.clock.c += 12;},
    JPrr:   function(p, r1, r2) {p.r.pc = (p.r[r1] << 8) + p.r[r2];p.clock.c += 4;},
    JRn:    function(p) {var v=p.memory.rb(p.r.pc++);v=GameboyJS.Util.getSignedValue(v);p.r.pc += v;p.clock.c += 12;},
    PUSHrr: function(p, r1, r2) {p.wr('sp', p.r.sp-1);p.memory.wb(p.r.sp, p.r[r1]);p.wr('sp', p.r.sp-1);p.memory.wb(p.r.sp, p.r[r2]);p.clock.c+=16;},
    POPrr:  function(p, r1, r2) {p.wr(r2, p.memory.rb(p.r.sp));p.wr('sp', p.r.sp+1);p.wr(r1, p.memory.rb(p.r.sp));p.wr('sp', p.r.sp+1);p.clock.c+=12;},
    RSTn:   function(p, n) {p.wr('sp', p.r.sp-1);p.memory.wb(p.r.sp,p.r.pc>>8);p.wr('sp', p.r.sp-1);p.memory.wb(p.r.sp,p.r.pc&0xFF);p.r.pc=n;p.clock.c+=16;},
    RET:    function(p) {p.r.pc = p.memory.rb(p.r.sp);p.wr('sp', p.r.sp+1);p.r.pc+=p.memory.rb(p.r.sp)<<8;p.wr('sp', p.r.sp+1);p.clock.c += 16;},
    RETcc:  function(p, cc) {if (GameboyJS.Util.testFlag(p, cc)){p.r.pc = p.memory.rb(p.r.sp);p.wr('sp', p.r.sp+1);p.r.pc+=p.memory.rb(p.r.sp)<<8;p.wr('sp', p.r.sp+1);p.clock.c+=12;}p.clock.c+=8;},
    CALLnn: function(p) {ops._CALLnn(p); p.clock.c+=24;},
    CALLccnn:function(p, cc) {if (GameboyJS.Util.testFlag(p, cc)){ops._CALLnn(p);p.clock.c+=12;}else{p.r.pc+=2;}p.clock.c+=12; },
    _CALLnn:function(p){p.wr('sp', p.r.sp - 1); p.memory.wb(p.r.sp, ((p.r.pc+2)&0xFF00)>>8);
        p.wr('sp', p.r.sp - 1); p.memory.wb(p.r.sp, (p.r.pc+2)&0x00FF);
        var j=p.memory.rb(p.r.pc)+(p.memory.rb(p.r.pc+1)<<8);p.r.pc=j;},
    CPL:    function(p) {p.wr('A', (~p.r.A)&0xFF);p.r.F|=0x60,p.clock.c += 4;},
    CCF:    function(p) {p.r.F&=0x9F;p.r.F&0x10?p.r.F&=0xE0:p.r.F|=0x10;p.clock.c += 4;},
    SCF:    function(p) {p.r.F&=0x9F;p.r.F|=0x10;p.clock.c+=4;},
    DAA:    function(p) {
        var sub = (p.r.F&0x40) ? 1 : 0; var h = (p.r.F&0x20)?1:0;var c = (p.r.F&0x10)?1:0;
        if (sub) {
            if (h) {
                p.r.A = (p.r.A - 0x6) & 0xFF;
            }
            if (c) {
                p.r.A -= 0x60;
            }
        } else {
            if ((p.r.A&0xF) > 9 || h) {
                p.r.A += 0x6;
            }
            if (p.r.A > 0x9F || c) {
                p.r.A += 0x60;
            }
        }
        if (p.r.A&0x100) c = 1;

        p.r.A &= 0xFF;
        p.r.F &= 0x40;if (p.r.A == 0) p.r.F|=0x80;if (c) p.r.F|=0x10;
        p.clock.c += 4;
    },
    HALT:   function(p) {p.halt(); p.clock.c+=4;},
    DI:     function(p) {p.disableInterrupts();p.clock.c += 4;},
    EI:     function(p) {p.enableInterrupts();p.clock.c += 4;},
    RETI:   function(p) {p.enableInterrupts();ops.RET(p);},
    CB:     function(p) {var opcode = p.memory.rb(p.r.pc++);
        GameboyJS.opcodeCbmap[opcode](p);
        p.clock.c+=4;}
};
GameboyJS.cpuOps = ops;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

var defaultOptions = {
    pad: {class: GameboyJS.Keyboard, mapping: null},
    zoom: 1,
    romReaders: [],
    statusContainerId: 'status',
    gameNameContainerId: 'game-name',
    errorContainerId: 'error'
};

// Gameboy class
//
// This object is the entry point of the application
// Will delegate user actions to the emulated devices
// and provide information where needed
var Gameboy = function(canvas, options) {
    options = options || {};
    this.options = GameboyJS.Util.extend({}, defaultOptions, options);

    var cpu = new GameboyJS.CPU(this);
    var screen = new GameboyJS.Screen(canvas, this.options.zoom);
    var gpu = new GameboyJS.GPU(screen, cpu);
    cpu.gpu = gpu;

    var pad = new this.options.pad.class(this.options.pad.mapping);
    var input = new GameboyJS.Input(cpu, pad);
    cpu.input = input;

    this.cpu = cpu;
    this.screen = screen;
    this.input = input;
    this.pad = pad;

    this.createRom(this.options.romReaders);

    this.statusContainer   = document.getElementById(this.options.statusContainerId) || document.createElement('div');
    this.gameNameContainer = document.getElementById(this.options.gameNameContainerId) || document.createElement('div');
    this.errorContainer    = document.getElementById(this.options.errorContainerId) || document.createElement('div');
};

// Create the ROM object and bind one or more readers
Gameboy.prototype.createRom = function (readers) {
    var rom = new GameboyJS.Rom(this);
    if (readers.length == 0) {
        // add the default rom reader
        var romReader = new GameboyJS.RomFileReader();
        rom.addReader(romReader);
    } else {
        for (var i in readers) {
            if (readers.hasOwnProperty(i)) {
                rom.addReader(readers[i]);
            }
        }
    }
};

Gameboy.prototype.startRom = function(rom) {
    this.errorContainer.classList.add('hide');
    this.cpu.reset();
    try {
        this.cpu.loadRom(rom.data);
        this.setStatus('Game Running :');
        this.setGameName(this.cpu.getGameName());
        this.cpu.run();
    } catch (e) {
        this.handleException(e);
    }
};

Gameboy.prototype.pause = function(value) {
    if (value) {
        this.setStatus('Game Paused :');
        this.cpu.pause();
    } else {
        this.setStatus('Game Running :');
        this.cpu.unpause();
    }
};

Gameboy.prototype.error = function(message) {
    this.setStatus('Error during execution');
    this.setError('An error occurred during execution:' + message);
    this.cpu.stop();
};

Gameboy.prototype.setStatus = function(status) {
    this.statusContainer.innerHTML = status;
};
// Display an error message
Gameboy.prototype.setError = function(message) {
    this.errorContainer.classList.remove('hide');
    this.errorContainer.innerHTML = message;
};
// Display the name of the game running
Gameboy.prototype.setGameName = function(name) {
    this.gameNameContainer.innerHTML = name;
};
Gameboy.prototype.setSoundEnabled = function(value) {
    if (value) {
        this.cpu.apu.connect();
    } else {
        this.cpu.apu.disconnect();
    }
};
Gameboy.prototype.setScreenZoom = function(value) {
    this.screen.setPixelSize(value);
};
Gameboy.prototype.handleException = function(e) {
    if (e instanceof GameboyJS.UnimplementedException) {
        if (e.fatal) {
            this.error('This cartridge is not supported ('+ e.message +')');
        } else {
            console.error(e.message);
        }
    } else {
        throw e;
    }
};
GameboyJS.Gameboy = Gameboy;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// Memory bank controllers

var MBC = {};

// Create an MBC instance depending on the type specified in the cartridge
MBC.getMbcInstance = function(memory, type) {
    var instance;
    switch (type) {
        case 0x00:
            instance = new MBC0(memory);
            break;
        case 0x01: case 0x02: case 0x03:
            instance = new MBC1(memory);
            break;
        case 0x0F: case 0x10: case 0x11: case 0x12: case 0x13:
            instance = new MBC3(memory);
            break;
        case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E:
            instance = new MBC5(memory);
            break;
        default:
            throw new GameboyJS.UnimplementedException('MBC type not supported');
    }

    return instance;
};

var MBC1 = function(memory) {
    this.memory = memory;
    this.romBankNumber = 1;
    this.mode = 0; // mode 0 = ROM, mode 1 = RAM
    this.ramEnabled = true;
    this.extRam = new GameboyJS.ExtRam();
};

MBC1.prototype.loadRam = function(game, size) {
    this.extRam.loadRam(game, size);
};

MBC1.prototype.manageWrite = function(addr, value) {
    switch (addr & 0xF000) {
        case 0x0000: case 0x1000: // enable RAM
            this.ramEnabled = (value & 0x0A) ? true : false;
            if (this.ramEnabled) {
                this.extRam.saveRamData();
            }
            break;
        case 0x2000: case 0x3000: // ROM bank number lower 5 bits
            value &= 0x1F;
            if (value == 0) value = 1;
            var mask = this.mode ? 0 : 0xE0;
            this.romBankNumber = (this.romBankNumber & mask) +value;
            this.memory.loadRomBank(this.romBankNumber);
            break;
        case 0x4000: case 0x5000: // RAM bank or high bits ROM
            value &= 0x03;
            if (this.mode == 0) { // ROM upper bits
                this.romBankNumber = (this.romBankNumber&0x1F) | (value << 5);
                this.memory.loadRomBank(this.romBankNumber);
            } else { // RAM bank
                this.extRam.setRamBank(value);
            }
            break;
        case 0x6000: case 0x7000: // ROM / RAM mode
            this.mode = value & 1;
            break;
        case 0xA000: case 0xB000:
            this.extRam.manageWrite(addr - 0xA000, value);
            break;
    }
};
MBC1.prototype.readRam = function(addr) {
    return this.extRam.manageRead(addr - 0xA000);
};

var MBC3 = function(memory) {
    this.memory = memory;
    this.romBankNumber = 1;
    this.ramEnabled = true;
    this.extRam = new GameboyJS.ExtRam();
};

MBC3.prototype.loadRam = function(game, size) {
    this.extRam.loadRam(game, size);
};

MBC3.prototype.manageWrite = function(addr, value) {
    switch (addr & 0xF000) {
        case 0x0000: case 0x1000: // enable RAM
            this.ramEnabled = (value & 0x0A) ? true : false;
            if (this.ramEnabled) {
                this.extRam.saveRamData();
            }
            break;
        case 0x2000: case 0x3000: // ROM bank number
            value &= 0x7F;
            if (value == 0) value = 1;
            this.romBankNumber = value;
            this.memory.loadRomBank(this.romBankNumber);
            break;
        case 0x4000: case 0x5000: // RAM bank
            this.extRam.setRamBank(value);
            break;
        case 0x6000: case 0x7000: // Latch clock data
            throw new GameboyJS.UnimplementedException('cartridge clock not supported', false);
            break;
        case 0xA000: case 0xB000:
            this.extRam.manageWrite(addr - 0xA000, value);
            break;
    }
};
MBC3.prototype.readRam = function(addr) {
    return this.extRam.manageRead(addr - 0xA000);
};

// declare MBC5 for compatibility with most cartriges
// does not support rumble feature
var MBC5 = MBC3;

// MBC0 exists for consistency and manages the no-MBC cartriges
var MBC0 = function(memory) {this.memory = memory;};

MBC0.prototype.manageWrite = function(addr, value) {
    this.memory.loadRomBank(value);
};
MBC0.prototype.readRam = function(addr) {return 0;};
MBC0.prototype.loadRam = function() {};

GameboyJS.MBC = MBC;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// Memory unit
var Memory = function(cpu) {
    this.MEM_SIZE = 65536; // 64KB

    this.MBCtype = 0;
    this.banksize = 0x4000;
    this.rom = null;
    this.mbc = null;
    this.cpu = cpu;
};

Memory.addresses = {
    VRAM_START : 0x8000,
    VRAM_END   : 0x9FFF,

    EXTRAM_START : 0xA000,
    EXTRAM_END   : 0xBFFF,

    OAM_START : 0xFE00,
    OAM_END   : 0xFE9F,

    DEVICE_START: 0xFF00,
    DEVICE_END:   0xFF7F
};

// Memory can be accessed as an Array
Memory.prototype = new Array();

Memory.prototype.reset = function() {
    this.length = this.MEM_SIZE;
    for (var i = Memory.addresses.VRAM_START; i <= Memory.addresses.VRAM_END; i++) {
        this[i] = 0;
    }
    for (var i = Memory.addresses.DEVICE_START; i <= Memory.addresses.DEVICE_END; i++) {
        this[i] = 0;
    }
    this[0xFFFF] = 0;
};

Memory.prototype.setRomData = function(data) {
    this.rom = data;
    this.loadRomBank(0);
    this.mbc = GameboyJS.MBC.getMbcInstance(this, this[0x147]);
    this.loadRomBank(1);
    this.mbc.loadRam(this.cpu.getGameName(), this.cpu.getRamSize());
};

Memory.prototype.loadRomBank = function(index) {
    var start = index ? 0x4000 : 0x0;
    var romStart = index * 0x4000;
    for (var i = 0; i < this.banksize; i++) {
        this[i + start] = this.rom[romStart + i];
    }
};

// Video ram accessor
Memory.prototype.vram = function(address) {
    if (address < Memory.addresses.VRAM_START || address > Memory.addresses.VRAM_END) {
        throw 'VRAM access in out of bounds address ' + address;
    }

    return this[address];
};

// OAM ram accessor
Memory.prototype.oamram = function(address) {
    if (address < Memory.addresses.OAM_START || address > Memory.addresses.OAM_END) {
        throw 'OAMRAM access in out of bounds address ' + address;
    }

    return this[address];
};

// Device ram accessor
Memory.prototype.deviceram = function(address, value) {
    if (address < Memory.addresses.DEVICERAM_START || address > Memory.addresses.DEVICERAM_END) {
        throw 'Device RAM access in out of bounds address ' + address;
    }
    if (typeof value === "undefined") {
        return this[address];
    } else {
        this[address] = value;
    }

};

// Memory read proxy function
// Used to centralize memory read access
Memory.prototype.rb = function (addr) {
    if (addr >= 0xFF10 && addr < 0xFF40) {
        var mask = apuMask[addr - 0xFF10];
        return this[addr] | mask;
    }
    if ((addr >= 0xA000 && addr < 0xC000)) {
        return this.mbc.readRam(addr);
    }
    return this[addr];
};

// Bitmasks for audio addresses reads
var apuMask = [
0x80,0x3F,0x00,0xFF,0xBF, // NR10-NR15
0xFF,0x3F,0x00,0xFF,0xBF, // NR20-NR25
0x7F,0xFF,0x9F,0xFF,0xBF, // NR30-NR35
0xFF,0xFF,0x00,0x00,0xBF, // NR40-NR45
0x00,0x00,0x70,           // NR50-NR52
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Wave RAM
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
];

// Memory write proxy function
// Used to centralize memory writes and delegate specific behaviour
// to the correct units
Memory.prototype.wb = function(addr, value) {
    if (addr < 0x8000 || (addr >= 0xA000 && addr < 0xC000)) { // MBC
        this.mbc.manageWrite(addr, value);
    } else if (addr >= 0xFF10 && addr <= 0xFF3F) { // sound registers
        this.cpu.apu.manageWrite(addr, value);
    } else if (addr == 0xFF00) { // input register
        this[addr] = ((this[addr] & 0x0F) | (value & 0x30));
    } else {
        this[addr] = value;
        if ((addr & 0xFF00) == 0xFF00) {
            if (addr == 0xFF02) {
                if (value & 0x80) {
                    this.cpu.enableSerialTransfer();
                }
            }
            if (addr == 0xFF04) {
                this.cpu.resetDivTimer();
            }
            if (addr == 0xFF46) { // OAM DMA transfer
                this.dmaTransfer(value);
            }
        }
    }
}

// Start a DMA transfer (OAM data from cartrige to RAM)
Memory.prototype.dmaTransfer = function(startAddressPrefix) {
    var startAddress = (startAddressPrefix << 8);
    for (var i = 0; i < 0xA0; i++) {
        this[Memory.addresses.OAM_START + i] = this[startAddress + i];
    }
};

GameboyJS.Memory = Memory;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

var ops = GameboyJS.cpuOps;
// Each opcode (0 to 0xFF) is associated to a CPU operation
// CPU operations are implemented separately
// The cbmap object holds operations for CB prefixed opcodes (0xCB00 to 0xCBFF)
// Non existent opcodes are commented out and marked empty
var map = {
    0x00: function(p){p.clock.c += 4;},
    0x01: function(p){ops.LDrrnn(p, 'B', 'C');},
    0x02: function(p){ops.LDrrar(p, 'B', 'C', 'A');},
    0x03: function(p){ops.INCrr(p, 'B', 'C');},
    0x04: function(p){ops.INCr(p, 'B');},
    0x05: function(p){ops.DECr(p, 'B');},
    0x06: function(p){ops.LDrn(p, 'B');},
    0x07: function(p){var out=p.r.A & 0x80?1:0; out ? p.r.F=0x10:p.r.F=0; p.wr('A', ((p.r.A<<1)+out)&0xFF);p.clock.c+=4;},
    0x08: function(p){ops.LDnnsp(p);},
    0x09: function(p){ops.ADDrrrr(p, 'H', 'L', 'B', 'C');},
    0x0A: function(p){ops.LDrrra(p, 'A', 'B', 'C');},
    0x0B: function(p){ops.DECrr(p, 'B', 'C');},
    0x0C: function(p){ops.INCr(p, 'C');},
    0x0D: function(p){ops.DECr(p, 'C');},
    0x0E: function(p){ops.LDrn(p, 'C');},
    0x0F: function(p){var out=p.r.A & 0x01; out ? p.r.F=0x10:p.r.F=0; p.wr('A', (p.r.A>>1)|(out*0x80));p.clock.c+=4;},

    0x10: function(p){p.r.pc++;p.clock.c+=4;},
    0x11: function(p){ops.LDrrnn(p, 'D', 'E');},
    0x12: function(p){ops.LDrrar(p, 'D', 'E', 'A');},
    0x13: function(p){ops.INCrr(p, 'D', 'E');},
    0x14: function(p){ops.INCr(p, 'D');},
    0x15: function(p){ops.DECr(p, 'D');},
    0x16: function(p){ops.LDrn(p, 'D');},
    0x17: function(p){var c = (p.r.F&0x10)?1:0;var out=p.r.A & 0x80?1:0; out ? p.r.F=0x10:p.r.F=0; p.wr('A',((p.r.A<<1)+c)&0xFF);p.clock.c+=4;},
    0x18: function(p){ops.JRn(p);},
    0x19: function(p){ops.ADDrrrr(p, 'H', 'L', 'D', 'E');},
    0x1A: function(p){ops.LDrrra(p, 'A', 'D', 'E');},
    0x1B: function(p){ops.DECrr(p, 'D', 'E');},
    0x1C: function(p){ops.INCr(p, 'E');},
    0x1D: function(p){ops.DECr(p, 'E');},
    0x1E: function(p){ops.LDrn(p, 'E');},
    0x1F: function(p){var c = (p.r.F&0x10)?1:0;var out=p.r.A & 0x01; out ? p.r.F=0x10:p.r.F=0; p.wr('A', (p.r.A>>1)|(c*0x80));p.clock.c+=4;},

    0x20: function(p){ops.JRccn(p, 'NZ');},
    0x21: function(p){ops.LDrrnn(p, 'H', 'L');},
    0x22: function(p){ops.LDrrar(p, 'H', 'L', 'A');ops.INCrr(p, 'H', 'L');p.clock.c -= 8;},
    0x23: function(p){ops.INCrr(p, 'H', 'L');},
    0x24: function(p){ops.INCr(p, 'H');},
    0x25: function(p){ops.DECr(p, 'H');},
    0x26: function(p){ops.LDrn(p, 'H');},
    0x27: function(p){ops.DAA(p);},
    0x28: function(p){ops.JRccn(p, 'Z');},
    0x29: function(p){ops.ADDrrrr(p, 'H', 'L', 'H', 'L');},
    0x2A: function(p){ops.LDrrra(p, 'A', 'H', 'L');ops.INCrr(p, 'H', 'L');p.clock.c -= 8;},
    0x2B: function(p){ops.DECrr(p, 'H', 'L');},
    0x2C: function(p){ops.INCr(p, 'L');},
    0x2D: function(p){ops.DECr(p, 'L');},
    0x2E: function(p){ops.LDrn(p, 'L');},
    0x2F: function(p){ops.CPL(p);},

    0x30: function(p){ops.JRccn(p, 'NC');},
    0x31: function(p){ops.LDspnn(p);},
    0x32: function(p){ops.LDrrar(p, 'H', 'L', 'A');ops.DECrr(p, 'H', 'L');p.clock.c -= 8;},
    0x33: function(p){ops.INCsp(p);},
    0x34: function(p){ops.INCrra(p, 'H', 'L');},
    0x35: function(p){ops.DECrra(p, 'H', 'L');},
    0x36: function(p){ops.LDrran(p, 'H', 'L');},
    0x37: function(p){ops.SCF(p);},
    0x38: function(p){ops.JRccn(p, 'C');},
    0x39: function(p){ops.ADDrrsp(p, 'H', 'L');},
    0x3A: function(p){ops.LDrrra(p, 'A', 'H', 'L');ops.DECrr(p, 'H', 'L');p.clock.c -= 8;},
    0x3B: function(p){ops.DECsp(p);},
    0x3C: function(p){ops.INCr(p, 'A');},
    0x3D: function(p){ops.DECr(p, 'A');},
    0x3E: function(p){ops.LDrn(p, 'A');},
    0x3F: function(p){ops.CCF(p);},

    0x40: function(p){ops.LDrr(p, 'B', 'B');},
    0x41: function(p){ops.LDrr(p, 'B', 'C');},
    0x42: function(p){ops.LDrr(p, 'B', 'D');},
    0x43: function(p){ops.LDrr(p, 'B', 'E');},
    0x44: function(p){ops.LDrr(p, 'B', 'H');},
    0x45: function(p){ops.LDrr(p, 'B', 'L');},
    0x46: function(p){ops.LDrrra(p, 'B', 'H', 'L');},
    0x47: function(p){ops.LDrr(p, 'B', 'A');},
    0x48: function(p){ops.LDrr(p, 'C', 'B');},
    0x49: function(p){ops.LDrr(p, 'C', 'C');},
    0x4A: function(p){ops.LDrr(p, 'C', 'D');},
    0x4B: function(p){ops.LDrr(p, 'C', 'E');},
    0x4C: function(p){ops.LDrr(p, 'C', 'H');},
    0x4D: function(p){ops.LDrr(p, 'C', 'L');},
    0x4E: function(p){ops.LDrrra(p, 'C', 'H', 'L');},
    0x4F: function(p){ops.LDrr(p, 'C', 'A');},

    0x50: function(p){ops.LDrr(p, 'D', 'B');},
    0x51: function(p){ops.LDrr(p, 'D', 'C');},
    0x52: function(p){ops.LDrr(p, 'D', 'D');},
    0x53: function(p){ops.LDrr(p, 'D', 'E');},
    0x54: function(p){ops.LDrr(p, 'D', 'H');},
    0x55: function(p){ops.LDrr(p, 'D', 'L');},
    0x56: function(p){ops.LDrrra(p, 'D', 'H', 'L');},
    0x57: function(p){ops.LDrr(p, 'D', 'A');},
    0x58: function(p){ops.LDrr(p, 'E', 'B');},
    0x59: function(p){ops.LDrr(p, 'E', 'C');},
    0x5A: function(p){ops.LDrr(p, 'E', 'D');},
    0x5B: function(p){ops.LDrr(p, 'E', 'E');},
    0x5C: function(p){ops.LDrr(p, 'E', 'H');},
    0x5D: function(p){ops.LDrr(p, 'E', 'L');},
    0x5E: function(p){ops.LDrrra(p, 'E', 'H', 'L');},
    0x5F: function(p){ops.LDrr(p, 'E', 'A');},

    0x60: function(p){ops.LDrr(p, 'H', 'B');},
    0x61: function(p){ops.LDrr(p, 'H', 'C');},
    0x62: function(p){ops.LDrr(p, 'H', 'D');},
    0x63: function(p){ops.LDrr(p, 'H', 'E');},
    0x64: function(p){ops.LDrr(p, 'H', 'H');},
    0x65: function(p){ops.LDrr(p, 'H', 'L');},
    0x66: function(p){ops.LDrrra(p, 'H', 'H', 'L');},
    0x67: function(p){ops.LDrr(p, 'H', 'A');},
    0x68: function(p){ops.LDrr(p, 'L', 'B');},
    0x69: function(p){ops.LDrr(p, 'L', 'C');},
    0x6A: function(p){ops.LDrr(p, 'L', 'D');},
    0x6B: function(p){ops.LDrr(p, 'L', 'E');},
    0x6C: function(p){ops.LDrr(p, 'L', 'H');},
    0x6D: function(p){ops.LDrr(p, 'L', 'L');},
    0x6E: function(p){ops.LDrrra(p, 'L', 'H', 'L');},
    0x6F: function(p){ops.LDrr(p, 'L', 'A');},

    0x70: function(p){ops.LDrrar(p, 'H', 'L', 'B');},
    0x71: function(p){ops.LDrrar(p, 'H', 'L', 'C');},
    0x72: function(p){ops.LDrrar(p, 'H', 'L', 'D');},
    0x73: function(p){ops.LDrrar(p, 'H', 'L', 'E');},
    0x74: function(p){ops.LDrrar(p, 'H', 'L', 'H');},
    0x75: function(p){ops.LDrrar(p, 'H', 'L', 'L');},
    0x76: function(p){ops.HALT(p);},
    0x77: function(p){ops.LDrrar(p, 'H', 'L', 'A');},
    0x78: function(p){ops.LDrr(p, 'A', 'B');},
    0x79: function(p){ops.LDrr(p, 'A', 'C');},
    0x7A: function(p){ops.LDrr(p, 'A', 'D');},
    0x7B: function(p){ops.LDrr(p, 'A', 'E');},
    0x7C: function(p){ops.LDrr(p, 'A', 'H');},
    0x7D: function(p){ops.LDrr(p, 'A', 'L');},
    0x7E: function(p){ops.LDrrra(p, 'A', 'H', 'L');},
    0x7F: function(p){ops.LDrr(p, 'A', 'A');},

    0x80: function(p){ops.ADDrr(p, 'A', 'B');},
    0x81: function(p){ops.ADDrr(p, 'A', 'C');},
    0x82: function(p){ops.ADDrr(p, 'A', 'D');},
    0x83: function(p){ops.ADDrr(p, 'A', 'E');},
    0x84: function(p){ops.ADDrr(p, 'A', 'H');},
    0x85: function(p){ops.ADDrr(p, 'A', 'L');},
    0x86: function(p){ops.ADDrrra(p, 'A', 'H', 'L');},
    0x87: function(p){ops.ADDrr(p, 'A', 'A');},
    0x88: function(p){ops.ADCrr(p, 'A', 'B');},
    0x89: function(p){ops.ADCrr(p, 'A', 'C');},
    0x8A: function(p){ops.ADCrr(p, 'A', 'D');},
    0x8B: function(p){ops.ADCrr(p, 'A', 'E');},
    0x8C: function(p){ops.ADCrr(p, 'A', 'H');},
    0x8D: function(p){ops.ADCrr(p, 'A', 'L');},
    0x8E: function(p){ops.ADCrrra(p, 'A', 'H', 'L');},
    0x8F: function(p){ops.ADCrr(p, 'A', 'A');},

    0x90: function(p){ops.SUBr(p, 'B');},
    0x91: function(p){ops.SUBr(p, 'C');},
    0x92: function(p){ops.SUBr(p, 'D');},
    0x93: function(p){ops.SUBr(p, 'E');},
    0x94: function(p){ops.SUBr(p, 'H');},
    0x95: function(p){ops.SUBr(p, 'L');},
    0x96: function(p){ops.SUBrra(p, 'H', 'L');},
    0x97: function(p){ops.SUBr(p, 'A');},
    0x98: function(p){ops.SBCr(p, 'B');},
    0x99: function(p){ops.SBCr(p, 'C');},
    0x9A: function(p){ops.SBCr(p, 'D');},
    0x9B: function(p){ops.SBCr(p, 'E');},
    0x9C: function(p){ops.SBCr(p, 'H');},
    0x9D: function(p){ops.SBCr(p, 'L');},
    0x9E: function(p){ops.SBCrra(p, 'H', 'L');},
    0x9F: function(p){ops.SBCr(p, 'A');},

    0xA0: function(p){ops.ANDr(p, 'B');},
    0xA1: function(p){ops.ANDr(p, 'C');},
    0xA2: function(p){ops.ANDr(p, 'D');},
    0xA3: function(p){ops.ANDr(p, 'E');},
    0xA4: function(p){ops.ANDr(p, 'H');},
    0xA5: function(p){ops.ANDr(p, 'L');},
    0xA6: function(p){ops.ANDrra(p, 'H', 'L');},
    0xA7: function(p){ops.ANDr(p, 'A');},
    0xA8: function(p){ops.XORr(p, 'B');},
    0xA9: function(p){ops.XORr(p, 'C');},
    0xAA: function(p){ops.XORr(p, 'D');},
    0xAB: function(p){ops.XORr(p, 'E');},
    0xAC: function(p){ops.XORr(p, 'H');},
    0xAD: function(p){ops.XORr(p, 'L');},
    0xAE: function(p){ops.XORrra(p, 'H', 'L');},
    0xAF: function(p){ops.XORr(p, 'A');},

    0xB0: function(p){ops.ORr(p, 'B');},
    0xB1: function(p){ops.ORr(p, 'C');},
    0xB2: function(p){ops.ORr(p, 'D');},
    0xB3: function(p){ops.ORr(p, 'E');},
    0xB4: function(p){ops.ORr(p, 'H');},
    0xB5: function(p){ops.ORr(p, 'L');},
    0xB6: function(p){ops.ORrra(p, 'H', 'L');},
    0xB7: function(p){ops.ORr(p, 'A');},
    0xB8: function(p){ops.CPr(p, 'B');},
    0xB9: function(p){ops.CPr(p, 'C');},
    0xBA: function(p){ops.CPr(p, 'D');},
    0xBB: function(p){ops.CPr(p, 'E');},
    0xBC: function(p){ops.CPr(p, 'H');},
    0xBD: function(p){ops.CPr(p, 'L');},
    0xBE: function(p){ops.CPrra(p, 'H', 'L');},
    0xBF: function(p){ops.CPr(p, 'A');},

    0xC0: function(p){ops.RETcc(p, 'NZ');},
    0xC1: function(p){ops.POPrr(p, 'B', 'C');},
    0xC2: function(p){ops.JPccnn(p, 'NZ');},
    0xC3: function(p){ops.JPnn(p);},
    0xC4: function(p){ops.CALLccnn(p, 'NZ');},
    0xC5: function(p){ops.PUSHrr(p, 'B', 'C');},
    0xC6: function(p){ops.ADDrn(p, 'A');},
    0xC7: function(p){ops.RSTn(p, 0x00);},
    0xC8: function(p){ops.RETcc(p, 'Z');},
    0xC9: function(p){ops.RET(p);},
    0xCA: function(p){ops.JPccnn(p, 'Z');},
    0xCB: function(p){ops.CB(p);},
    0xCC: function(p){ops.CALLccnn(p, 'Z');},
    0xCD: function(p){ops.CALLnn(p);},
    0xCE: function(p){ops.ADCrn(p, 'A');},
    0xCF: function(p){ops.RSTn(p, 0x08);},

    0xD0: function(p){ops.RETcc(p, 'NC');},
    0xD1: function(p){ops.POPrr(p, 'D', 'E');},
    0xD2: function(p){ops.JPccnn(p, 'NC');},
    //0xD3 empty
    0xD4: function(p){ops.CALLccnn(p, 'NC');},
    0xD5: function(p){ops.PUSHrr(p, 'D', 'E');},
    0xD6: function(p){ops.SUBn(p);},
    0xD7: function(p){ops.RSTn(p, 0x10);},
    0xD8: function(p){ops.RETcc(p, 'C');},
    0xD9: function(p){ops.RETI(p);},
    0xDA: function(p){ops.JPccnn(p, 'C');},
    //0xDB empty
    0xDC: function(p){ops.CALLccnn(p, 'C');},
    //0xDD empty
    0xDE: function(p){ops.SBCn(p);},
    0xDF: function(p){ops.RSTn(p, 0x18);},

    0xE0: function(p){ops.LDHnar(p, 'A');},
    0xE1: function(p){ops.POPrr(p, 'H', 'L');},
    0xE2: function(p){ops.LDrar(p, 'C', 'A');},
    //0xE3 empty
    //0xE4 empty
    0xE5: function(p){ops.PUSHrr(p, 'H', 'L');},
    0xE6: function(p){ops.ANDn(p);},
    0xE7: function(p){ops.RSTn(p, 0x20);},
    0xE8: function(p){ops.ADDspn(p);},
    0xE9: function(p){ops.JPrr(p, 'H', 'L');},
    0xEA: function(p){ops.LDnnar(p, 'A');},
    //0xEB empty
    //0xEC empty
    //0xED empty
    0xEE: function(p){ops.XORn(p);},
    0xEF: function(p){ops.RSTn(p, 0x28);},

    0xF0: function(p){ops.LDHrna(p, 'A');},
    0xF1: function(p){ops.POPrr(p, 'A', 'F');},
    0xF2: function(p){ops.LDrra(p, 'A', 'C');},
    0xF3: function(p){ops.DI(p);},
    //0xF4 empty
    0xF5: function(p){ops.PUSHrr(p, 'A', 'F');},
    0xF6: function(p){ops.ORn(p);},
    0xF7: function(p){ops.RSTn(p, 0x30);},
    0xF8: function(p){ops.LDrrspn(p, 'H', 'L');},
    0xF9: function(p){ops.LDsprr(p, 'H', 'L');},
    0xFA: function(p){ops.LDrnna(p, 'A');},
    0xFB: function(p){ops.EI(p);},
    //0xFC empty
    //0xFD empty
    0xFE: function(p){ops.CPn(p);},
    0xFF: function(p){ops.RSTn(p, 0x38);}
};

var cbmap = {
    0x00: function(p){ops.RLCr(p, 'B');},
    0x01: function(p){ops.RLCr(p, 'C');},
    0x02: function(p){ops.RLCr(p, 'D');},
    0x03: function(p){ops.RLCr(p, 'E');},
    0x04: function(p){ops.RLCr(p, 'H');},
    0x05: function(p){ops.RLCr(p, 'L');},
    0x06: function(p){ops.RLCrra(p, 'H', 'L');},
    0x07: function(p){ops.RLCr(p, 'A');},
    0x08: function(p){ops.RRCr(p, 'B');},
    0x09: function(p){ops.RRCr(p, 'C');},
    0x0A: function(p){ops.RRCr(p, 'D');},
    0x0B: function(p){ops.RRCr(p, 'E');},
    0x0C: function(p){ops.RRCr(p, 'H');},
    0x0D: function(p){ops.RRCr(p, 'L');},
    0x0E: function(p){ops.RRCrra(p, 'H', 'L');},
    0x0F: function(p){ops.RRCr(p, 'A');},

    0x10: function(p){ops.RLr(p, 'B');},
    0x11: function(p){ops.RLr(p, 'C');},
    0x12: function(p){ops.RLr(p, 'D');},
    0x13: function(p){ops.RLr(p, 'E');},
    0x14: function(p){ops.RLr(p, 'H');},
    0x15: function(p){ops.RLr(p, 'L');},
    0x16: function(p){ops.RLrra(p, 'H', 'L');},
    0x17: function(p){ops.RLr(p, 'A');},
    0x18: function(p){ops.RRr(p, 'B');},
    0x19: function(p){ops.RRr(p, 'C');},
    0x1A: function(p){ops.RRr(p, 'D');},
    0x1B: function(p){ops.RRr(p, 'E');},
    0x1C: function(p){ops.RRr(p, 'H');},
    0x1D: function(p){ops.RRr(p, 'L');},
    0x1E: function(p){ops.RRrra(p, 'H', 'L');},
    0x1F: function(p){ops.RRr(p, 'A');},

    0x20: function(p){ops.SLAr(p, 'B');},
    0x21: function(p){ops.SLAr(p, 'C');},
    0x22: function(p){ops.SLAr(p, 'D');},
    0x23: function(p){ops.SLAr(p, 'E');},
    0x24: function(p){ops.SLAr(p, 'H');},
    0x25: function(p){ops.SLAr(p, 'L');},
    0x26: function(p){ops.SLArra(p, 'H', 'L');},
    0x27: function(p){ops.SLAr(p, 'A');},
    0x28: function(p){ops.SRAr(p, 'B');},
    0x29: function(p){ops.SRAr(p, 'C');},
    0x2A: function(p){ops.SRAr(p, 'D');},
    0x2B: function(p){ops.SRAr(p, 'E');},
    0x2C: function(p){ops.SRAr(p, 'H');},
    0x2D: function(p){ops.SRAr(p, 'L');},
    0x2E: function(p){ops.SRArra(p, 'H', 'L');},
    0x2F: function(p){ops.SRAr(p, 'A');},

    0x30: function(p){ops.SWAPr(p, 'B');},
    0x31: function(p){ops.SWAPr(p, 'C');},
    0x32: function(p){ops.SWAPr(p, 'D');},
    0x33: function(p){ops.SWAPr(p, 'E');},
    0x34: function(p){ops.SWAPr(p, 'H');},
    0x35: function(p){ops.SWAPr(p, 'L');},
    0x36: function(p){ops.SWAPrra(p, 'H', 'L');},
    0x37: function(p){ops.SWAPr(p, 'A');},
    0x38: function(p){ops.SRLr(p, 'B');},
    0x39: function(p){ops.SRLr(p, 'C');},
    0x3A: function(p){ops.SRLr(p, 'D');},
    0x3B: function(p){ops.SRLr(p, 'E');},
    0x3C: function(p){ops.SRLr(p, 'H');},
    0x3D: function(p){ops.SRLr(p, 'L');},
    0x3E: function(p){ops.SRLrra(p, 'H', 'L');},
    0x3F: function(p){ops.SRLr(p, 'A');},

    0x40: function(p){ops.BITir(p, 0, 'B');},
    0x41: function(p){ops.BITir(p, 0, 'C');},
    0x42: function(p){ops.BITir(p, 0, 'D');},
    0x43: function(p){ops.BITir(p, 0, 'E');},
    0x44: function(p){ops.BITir(p, 0, 'H');},
    0x45: function(p){ops.BITir(p, 0, 'L');},
    0x46: function(p){ops.BITirra(p, 0, 'H', 'L');},
    0x47: function(p){ops.BITir(p, 0, 'A');},
    0x48: function(p){ops.BITir(p, 1, 'B');},
    0x49: function(p){ops.BITir(p, 1, 'C');},
    0x4A: function(p){ops.BITir(p, 1, 'D');},
    0x4B: function(p){ops.BITir(p, 1, 'E');},
    0x4C: function(p){ops.BITir(p, 1, 'H');},
    0x4D: function(p){ops.BITir(p, 1, 'L');},
    0x4E: function(p){ops.BITirra(p, 1, 'H', 'L');},
    0x4F: function(p){ops.BITir(p, 1, 'A');},

    0x50: function(p){ops.BITir(p, 2, 'B');},
    0x51: function(p){ops.BITir(p, 2, 'C');},
    0x52: function(p){ops.BITir(p, 2, 'D');},
    0x53: function(p){ops.BITir(p, 2, 'E');},
    0x54: function(p){ops.BITir(p, 2, 'H');},
    0x55: function(p){ops.BITir(p, 2, 'L');},
    0x56: function(p){ops.BITirra(p, 2, 'H', 'L');},
    0x57: function(p){ops.BITir(p, 2, 'A');},
    0x58: function(p){ops.BITir(p, 3, 'B');},
    0x59: function(p){ops.BITir(p, 3, 'C');},
    0x5A: function(p){ops.BITir(p, 3, 'D');},
    0x5B: function(p){ops.BITir(p, 3, 'E');},
    0x5C: function(p){ops.BITir(p, 3, 'H');},
    0x5D: function(p){ops.BITir(p, 3, 'L');},
    0x5E: function(p){ops.BITirra(p, 3, 'H', 'L');},
    0x5F: function(p){ops.BITir(p, 3, 'A');},

    0x60: function(p){ops.BITir(p, 4, 'B');},
    0x61: function(p){ops.BITir(p, 4, 'C');},
    0x62: function(p){ops.BITir(p, 4, 'D');},
    0x63: function(p){ops.BITir(p, 4, 'E');},
    0x64: function(p){ops.BITir(p, 4, 'H');},
    0x65: function(p){ops.BITir(p, 4, 'L');},
    0x66: function(p){ops.BITirra(p, 4, 'H', 'L');},
    0x67: function(p){ops.BITir(p, 4, 'A');},
    0x68: function(p){ops.BITir(p, 5, 'B');},
    0x69: function(p){ops.BITir(p, 5, 'C');},
    0x6A: function(p){ops.BITir(p, 5, 'D');},
    0x6B: function(p){ops.BITir(p, 5, 'E');},
    0x6C: function(p){ops.BITir(p, 5, 'H');},
    0x6D: function(p){ops.BITir(p, 5, 'L');},
    0x6E: function(p){ops.BITirra(p, 5, 'H', 'L');},
    0x6F: function(p){ops.BITir(p, 5, 'A');},

    0x70: function(p){ops.BITir(p, 6, 'B');},
    0x71: function(p){ops.BITir(p, 6, 'C');},
    0x72: function(p){ops.BITir(p, 6, 'D');},
    0x73: function(p){ops.BITir(p, 6, 'E');},
    0x74: function(p){ops.BITir(p, 6, 'H');},
    0x75: function(p){ops.BITir(p, 6, 'L');},
    0x76: function(p){ops.BITirra(p, 6, 'H', 'L');},
    0x77: function(p){ops.BITir(p, 6, 'A');},
    0x78: function(p){ops.BITir(p, 7, 'B');},
    0x79: function(p){ops.BITir(p, 7, 'C');},
    0x7A: function(p){ops.BITir(p, 7, 'D');},
    0x7B: function(p){ops.BITir(p, 7, 'E');},
    0x7C: function(p){ops.BITir(p, 7, 'H');},
    0x7D: function(p){ops.BITir(p, 7, 'L');},
    0x7E: function(p){ops.BITirra(p, 7, 'H', 'L');},
    0x7F: function(p){ops.BITir(p, 7, 'A');},

    0x80: function(p){ops.RESir(p, 0, 'B');},
    0x81: function(p){ops.RESir(p, 0, 'C');},
    0x82: function(p){ops.RESir(p, 0, 'D');},
    0x83: function(p){ops.RESir(p, 0, 'E');},
    0x84: function(p){ops.RESir(p, 0, 'H');},
    0x85: function(p){ops.RESir(p, 0, 'L');},
    0x86: function(p){ops.RESirra(p, 0, 'H', 'L');},
    0x87: function(p){ops.RESir(p, 0, 'A');},
    0x88: function(p){ops.RESir(p, 1, 'B');},
    0x89: function(p){ops.RESir(p, 1, 'C');},
    0x8A: function(p){ops.RESir(p, 1, 'D');},
    0x8B: function(p){ops.RESir(p, 1, 'E');},
    0x8C: function(p){ops.RESir(p, 1, 'H');},
    0x8D: function(p){ops.RESir(p, 1, 'L');},
    0x8E: function(p){ops.RESirra(p, 1, 'H', 'L');},
    0x8F: function(p){ops.RESir(p, 1, 'A');},

    0x90: function(p){ops.RESir(p, 2, 'B');},
    0x91: function(p){ops.RESir(p, 2, 'C');},
    0x92: function(p){ops.RESir(p, 2, 'D');},
    0x93: function(p){ops.RESir(p, 2, 'E');},
    0x94: function(p){ops.RESir(p, 2, 'H');},
    0x95: function(p){ops.RESir(p, 2, 'L');},
    0x96: function(p){ops.RESirra(p, 2, 'H', 'L');},
    0x97: function(p){ops.RESir(p, 2, 'A');},
    0x98: function(p){ops.RESir(p, 3, 'B');},
    0x99: function(p){ops.RESir(p, 3, 'C');},
    0x9A: function(p){ops.RESir(p, 3, 'D');},
    0x9B: function(p){ops.RESir(p, 3, 'E');},
    0x9C: function(p){ops.RESir(p, 3, 'H');},
    0x9D: function(p){ops.RESir(p, 3, 'L');},
    0x9E: function(p){ops.RESirra(p, 3, 'H', 'L');},
    0x9F: function(p){ops.RESir(p, 3, 'A');},

    0xA0: function(p){ops.RESir(p, 4, 'B');},
    0xA1: function(p){ops.RESir(p, 4, 'C');},
    0xA2: function(p){ops.RESir(p, 4, 'D');},
    0xA3: function(p){ops.RESir(p, 4, 'E');},
    0xA4: function(p){ops.RESir(p, 4, 'H');},
    0xA5: function(p){ops.RESir(p, 4, 'L');},
    0xA6: function(p){ops.RESirra(p, 4, 'H', 'L');},
    0xA7: function(p){ops.RESir(p, 4, 'A');},
    0xA8: function(p){ops.RESir(p, 5, 'B');},
    0xA9: function(p){ops.RESir(p, 5, 'C');},
    0xAA: function(p){ops.RESir(p, 5, 'D');},
    0xAB: function(p){ops.RESir(p, 5, 'E');},
    0xAC: function(p){ops.RESir(p, 5, 'H');},
    0xAD: function(p){ops.RESir(p, 5, 'L');},
    0xAE: function(p){ops.RESirra(p, 5, 'H', 'L');},
    0xAF: function(p){ops.RESir(p, 5, 'A');},

    0xB0: function(p){ops.RESir(p, 6, 'B');},
    0xB1: function(p){ops.RESir(p, 6, 'C');},
    0xB2: function(p){ops.RESir(p, 6, 'D');},
    0xB3: function(p){ops.RESir(p, 6, 'E');},
    0xB4: function(p){ops.RESir(p, 6, 'H');},
    0xB5: function(p){ops.RESir(p, 6, 'L');},
    0xB6: function(p){ops.RESirra(p, 6, 'H', 'L');},
    0xB7: function(p){ops.RESir(p, 6, 'A');},
    0xB8: function(p){ops.RESir(p, 7, 'B');},
    0xB9: function(p){ops.RESir(p, 7, 'C');},
    0xBA: function(p){ops.RESir(p, 7, 'D');},
    0xBB: function(p){ops.RESir(p, 7, 'E');},
    0xBC: function(p){ops.RESir(p, 7, 'H');},
    0xBD: function(p){ops.RESir(p, 7, 'L');},
    0xBE: function(p){ops.RESirra(p, 7, 'H', 'L');},
    0xBF: function(p){ops.RESir(p, 7, 'A');},

    0xC0: function(p){ops.SETir(p, 0, 'B');},
    0xC1: function(p){ops.SETir(p, 0, 'C');},
    0xC2: function(p){ops.SETir(p, 0, 'D');},
    0xC3: function(p){ops.SETir(p, 0, 'E');},
    0xC4: function(p){ops.SETir(p, 0, 'H');},
    0xC5: function(p){ops.SETir(p, 0, 'L');},
    0xC6: function(p){ops.SETirra(p, 0, 'H', 'L');},
    0xC7: function(p){ops.SETir(p, 0, 'A');},
    0xC8: function(p){ops.SETir(p, 1, 'B');},
    0xC9: function(p){ops.SETir(p, 1, 'C');},
    0xCA: function(p){ops.SETir(p, 1, 'D');},
    0xCB: function(p){ops.SETir(p, 1, 'E');},
    0xCC: function(p){ops.SETir(p, 1, 'H');},
    0xCD: function(p){ops.SETir(p, 1, 'L');},
    0xCE: function(p){ops.SETirra(p, 1, 'H', 'L');},
    0xCF: function(p){ops.SETir(p, 1, 'A');},

    0xD0: function(p){ops.SETir(p, 2, 'B');},
    0xD1: function(p){ops.SETir(p, 2, 'C');},
    0xD2: function(p){ops.SETir(p, 2, 'D');},
    0xD3: function(p){ops.SETir(p, 2, 'E');},
    0xD4: function(p){ops.SETir(p, 2, 'H');},
    0xD5: function(p){ops.SETir(p, 2, 'L');},
    0xD6: function(p){ops.SETirra(p, 2, 'H', 'L');},
    0xD7: function(p){ops.SETir(p, 2, 'A');},
    0xD8: function(p){ops.SETir(p, 3, 'B');},
    0xD9: function(p){ops.SETir(p, 3, 'C');},
    0xDA: function(p){ops.SETir(p, 3, 'D');},
    0xDB: function(p){ops.SETir(p, 3, 'E');},
    0xDC: function(p){ops.SETir(p, 3, 'H');},
    0xDD: function(p){ops.SETir(p, 3, 'L');},
    0xDE: function(p){ops.SETirra(p, 3, 'H', 'L');},
    0xDF: function(p){ops.SETir(p, 3, 'A');},

    0xE0: function(p){ops.SETir(p, 4, 'B');},
    0xE1: function(p){ops.SETir(p, 4, 'C');},
    0xE2: function(p){ops.SETir(p, 4, 'D');},
    0xE3: function(p){ops.SETir(p, 4, 'E');},
    0xE4: function(p){ops.SETir(p, 4, 'H');},
    0xE5: function(p){ops.SETir(p, 4, 'L');},
    0xE6: function(p){ops.SETirra(p, 4, 'H', 'L');},
    0xE7: function(p){ops.SETir(p, 4, 'A');},
    0xE8: function(p){ops.SETir(p, 5, 'B');},
    0xE9: function(p){ops.SETir(p, 5, 'C');},
    0xEA: function(p){ops.SETir(p, 5, 'D');},
    0xEB: function(p){ops.SETir(p, 5, 'E');},
    0xEC: function(p){ops.SETir(p, 5, 'H');},
    0xED: function(p){ops.SETir(p, 5, 'L');},
    0xEE: function(p){ops.SETirra(p, 5, 'H', 'L');},
    0xEF: function(p){ops.SETir(p, 5, 'A');},

    0xF0: function(p){ops.SETir(p, 6, 'B');},
    0xF1: function(p){ops.SETir(p, 6, 'C');},
    0xF2: function(p){ops.SETir(p, 6, 'D');},
    0xF3: function(p){ops.SETir(p, 6, 'E');},
    0xF4: function(p){ops.SETir(p, 6, 'H');},
    0xF5: function(p){ops.SETir(p, 6, 'L');},
    0xF6: function(p){ops.SETirra(p, 6, 'H', 'L');},
    0xF7: function(p){ops.SETir(p, 6, 'A');},
    0xF8: function(p){ops.SETir(p, 7, 'B');},
    0xF9: function(p){ops.SETir(p, 7, 'C');},
    0xFA: function(p){ops.SETir(p, 7, 'D');},
    0xFB: function(p){ops.SETir(p, 7, 'E');},
    0xFC: function(p){ops.SETir(p, 7, 'H');},
    0xFD: function(p){ops.SETir(p, 7, 'L');},
    0xFE: function(p){ops.SETirra(p, 7, 'H', 'L');},
    0xFF: function(p){ops.SETir(p, 7, 'A');}
};
GameboyJS.opcodeMap = map;
GameboyJS.opcodeCbmap = cbmap;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// A RomAjaxReader is able to load a file through an AJAX request
var RomAjaxReader = function() {

};

// The callback argument will be called when a file is successfully
// read, with the data as argument (Uint8Array)
RomAjaxReader.prototype.setCallback = function(onLoadCallback) {
    this.callback = onLoadCallback;
};

// This function should be called by application code
// and will trigger the AJAX call itself and push data to the ROM object
RomAjaxReader.prototype.loadFromUrl = function(url) {
    if (!url) {
        throw 'No url has been set in order to load a ROM file.';
    }
    var cb = this.callback;

    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, true);
    xhr.responseType = "arraybuffer";
    xhr.onload = function() {
        var rom = new Uint8Array(xhr.response);
        cb && cb(rom);
    };

    xhr.send();
};

GameboyJS.RomAjaxReader = RomAjaxReader;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// A RomDropFileReader is able to load a drag and dropped file
var RomDropFileReader = function(el) {
    this.dropElement = el;
    if (!this.dropElement) {
        throw 'The RomDropFileReader needs a drop zone.';
    }

    var self = this;
    this.dropElement.addEventListener('dragenter', function(e) {
        e.preventDefault();
        e.target.classList.add('drag-active');
    });
    this.dropElement.addEventListener('dragleave', function(e) {
        e.preventDefault();
        e.target.classList.remove('drag-active');
    });
    this.dropElement.addEventListener('dragover', function(e) {
        e.preventDefault();
    });
    this.dropElement.addEventListener('drop', function (e) {
        e.target.classList.remove('drag-active');
        if (e.dataTransfer.files.length == 0) {
            return;
        }
        e.preventDefault();
        self.loadFromFile(e.dataTransfer.files[0]);
    });
};

// The callback argument will be called when a file is successfully
// read, with the data as argument (Uint8Array)
RomDropFileReader.prototype.setCallback = function(onLoadCallback) {
    this.callback = onLoadCallback;
};

// The file loading logic is the same as the regular file reader
RomDropFileReader.prototype.loadFromFile = function(file) {
    if (file === undefined) {
        return;
    }
    var fr = new FileReader();
    var cb = this.callback;

    fr.onload = function() {
        cb && cb(new Uint8Array(fr.result));
    };
    fr.onerror = function(e) {
        console.log('Error reading the file', e.target.error.code)
    };
    fr.readAsArrayBuffer(file);
};

GameboyJS.RomDropFileReader = RomDropFileReader;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// A RomFileReader is able to load a local file from an input element
//
// Expects to be provided a file input element,
// or will try to find one with the "file" DOM ID
var RomFileReader = function(el) {
    this.domElement = el || document.getElementById('file');
    if (!this.domElement) {
        throw 'The RomFileReader needs a valid input element.';
    }

    var self = this;
    this.domElement.addEventListener('change', function(e){
        self.loadFromFile(e.target.files[0]);
    });
};

// The callback argument will be called when a file is successfully
// read, with the data as argument (Uint8Array)
RomFileReader.prototype.setCallback = function(onLoadCallback) {
    this.callback = onLoadCallback;
};

// Automatically called when the DOM input is provided with a file
RomFileReader.prototype.loadFromFile = function(file) {
    if (file === undefined) {
        return;
    }
    var fr = new FileReader();
    var cb = this.callback;

    fr.onload = function() {
        cb && cb(new Uint8Array(fr.result));
    };
    fr.onerror = function(e) {
        console.log('Error reading the file', e.target.error.code)
    };
    fr.readAsArrayBuffer(file);
};

GameboyJS.RomFileReader = RomFileReader;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";


var Rom = function(gameboy, romReader) {
    this.gameboy = gameboy;
    if (romReader) {
        this.addReader(romReader);
    }
};

Rom.prototype.addReader = function(romReader) {
    var self = this;
    romReader.setCallback(function(data) {
        if (!validate(data)) {
            self.gameboy.error('The file is not a valid GameBoy ROM.');
            return;
        }
        self.data = data;
        self.gameboy.startRom(self);
    });
};

// Validate the checksum of the cartridge header
function validate(data) {
    var hash = 0;
    for (var i = 0x134; i <= 0x14C; i++) {
        hash = hash - data[i] - 1;
    }
    return (hash & 0xFF) == data[0x14D];
};

GameboyJS.Rom = Rom;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// Handlers for the Serial port of the Gameboy

// The ConsoleSerial is an output-only serial port
// designed for debug purposes as some test roms output data on the serial port
//
// Will regularly output the received byte (converted to string) in the console logs
// This handler always push the value 0xFF as an input
var ConsoleSerial = {
    current: '',
    timeout: null,
    out: function(data) {
        ConsoleSerial.current += String.fromCharCode(data);
        if (data == 10) {
            ConsoleSerial.print();
        } else {
            clearTimeout(ConsoleSerial.timeout);
            ConsoleSerial.timeout = setTimeout(ConsoleSerial.print, 500);
        }
    },
    in: function() {
        return 0xFF;
    },
    print: function() {
        clearTimeout(ConsoleSerial.timeout);
        console.log('serial: '+ConsoleSerial.current);
        ConsoleSerial.current = '';
    }
};
GameboyJS.ConsoleSerial = ConsoleSerial;

// A DummySerial outputs nothing and always inputs 0xFF
var DummySerial = {
    out: function() {},
    in: function() {
        return 0xFF;
    }
};
GameboyJS.DummySerial = DummySerial;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// Audio Processing unit
// Listens the write accesses to the audio-reserved memory addresses
// and dispatches the data to the sound channels
var APU = function(memory) {
    this.memory = memory;
    this.enabled = false;

    AudioContext = window.AudioContext || window.webkitAudioContext;
    var audioContext = new AudioContext();

    this.channel1 = new GameboyJS.Channel1(this, 1, audioContext);
    this.channel2 = new GameboyJS.Channel1(this, 2, audioContext);
    this.channel3 = new GameboyJS.Channel3(this, 3, audioContext);
    this.channel4 = new GameboyJS.Channel4(this, 4, audioContext);

};
APU.prototype.connect = function() {
    this.channel1.enable();
    this.channel2.enable();
    this.channel3.enable();
};
APU.prototype.disconnect = function() {
    this.channel1.disable();
    this.channel2.disable();
    this.channel3.disable();
};
// Updates the states of each channel given the elapsed time
// (in instructions) since last update
APU.prototype.update = function(clockElapsed) {
    if (this.enabled == false) return;

    this.channel1.update(clockElapsed);
    this.channel2.update(clockElapsed);
    this.channel3.update(clockElapsed);
    this.channel4.update(clockElapsed);
};
APU.prototype.setSoundFlag = function(channel, value) {
    var mask = 0xFF - (1 << (channel - 1));
    value = value << (channel - 1)
    var byteValue = this.memory.rb(APU.registers.NR52);
    byteValue &= mask;
    byteValue |= value;
    this.memory[APU.registers.NR52] = byteValue;
};
// Manage writes to audio registers
// Will update the channels depending on the address
APU.prototype.manageWrite = function(addr, value) {
    if (this.enabled == false && addr < APU.registers.NR52) {
        return;
    }
    this.memory[addr] = value;

    switch (addr) {
        // Channel 1 addresses
        case 0xFF10:
            this.channel1.clockSweep = 0;
            this.channel1.sweepTime = ((value & 0x70) >> 4);
            this.channel1.sweepSign = (value & 0x08) ? -1 : 1;
            this.channel1.sweepShifts = (value & 0x07);
            this.channel1.sweepCount = this.channel1.sweepShifts;
            break;
        case 0xFF11:
            // todo : bits 6-7
            this.channel1.setLength(value & 0x3F);
            break;
        case 0xFF12:
            this.channel1.envelopeSign = (value & 0x08) ? 1 : -1;
            var envelopeVolume = (value & 0xF0) >> 4;
            this.channel1.setEnvelopeVolume(envelopeVolume);
            this.channel1.envelopeStep = (value & 0x07);
            break;
        case 0xFF13:
            var frequency = this.channel1.getFrequency();
            frequency &= 0xF00;
            frequency |= value;
            this.channel1.setFrequency(frequency);
            break;
        case 0xFF14:
            var frequency = this.channel1.getFrequency();
            frequency &= 0xFF;
            frequency |= (value & 7) << 8;
            this.channel1.setFrequency(frequency);
            this.channel1.lengthCheck = (value & 0x40) ? true : false;
            if (value & 0x80) this.channel1.play();
            break;

        // Channel 2 addresses
        case 0xFF16:
            // todo : bits 6-7
            this.channel2.setLength(value & 0x3F);
            break;
        case 0xFF17:
            this.channel2.envelopeSign = (value & 0x08) ? 1 : -1;
            var envelopeVolume = (value & 0xF0) >> 4;
            this.channel2.setEnvelopeVolume(envelopeVolume);
            this.channel2.envelopeStep = (value & 0x07);
            break;
        case 0xFF18:
            var frequency = this.channel2.getFrequency();
            frequency &= 0xF00;
            frequency |= value;
            this.channel2.setFrequency(frequency);
            break;
        case 0xFF19:
            var frequency = this.channel2.getFrequency();
            frequency &= 0xFF;
            frequency |= (value & 7) << 8;
            this.channel2.setFrequency(frequency);
            this.channel2.lengthCheck = (value & 0x40) ? true : false;
            if (value & 0x80) {
                this.channel2.play();
            }
            break;

        // Channel 3 addresses
        case 0xFF1A:
            // todo
            break;
        case 0xFF1B:
            this.channel3.setLength(value);
            break;
        case 0xFF1C:
            // todo
            break;
        case 0xFF1D:
            var frequency = this.channel3.getFrequency();
            frequency &= 0xF00;
            frequency |= value;
            this.channel3.setFrequency(frequency);
            break;
        case 0xFF1E:
            var frequency = this.channel3.getFrequency();
            frequency &= 0xFF;
            frequency |= (value & 7) << 8;
            this.channel3.setFrequency(frequency);
            this.channel3.lengthCheck = (value & 0x40) ? true : false;
            if (value & 0x80) {
                this.channel3.play();
            }
            break;

        // Channel 4 addresses
        case 0xFF20:
            this.channel4.setLength(value & 0x3F);
            break;
        case 0xFF21:
            // todo
            break;
        case 0xFF22:
            // todo
            break;
        case 0xFF23:
            this.channel4.lengthCheck = (value & 0x40) ? true : false;
            if (value & 0x80) {
                this.channel4.play();
            }
            break;

        // channel 3 wave bytes
        case 0xFF30:case 0xFF31:case 0xFF32:case 0xFF33:case 0xFF34:case 0xFF35:case 0xFF36:case 0xFF37:
        case 0xFF38:case 0xFF39:case 0xFF3A:case 0xFF3B:case 0xFF3C:case 0xFF3D:case 0xFF3E:case 0xFF3F:
            var index = addr - 0xFF30;
            this.channel3.setWaveBufferByte(index, value);
            break;

        // general audio switch
        case 0xFF26:
            value &= 0xF0;
            this.memory[addr] = value;
            this.enabled = (value & 0x80) == 0 ? false : true;
            if (!this.enabled) {
                for (var i = 0xFF10; i < 0xFF27; i++)
                    this.memory[i] = 0;
                // todo stop sound
            }
            break;
    }
};

APU.registers = {
    NR10: 0xFF10,
    NR11: 0xFF11,
    NR12: 0xFF12,
    NR13: 0xFF13,
    NR14: 0xFF14,

    NR21: 0xFF16,
    NR22: 0xFF17,
    NR23: 0xFF18,
    NR24: 0xFF19,

    NR30: 0xFF1A,
    NR31: 0xFF1B,
    NR32: 0xFF1C,
    NR33: 0xFF1D,
    NR34: 0xFF1E,

    NR41: 0xFF20,
    NR42: 0xFF21,
    NR43: 0xFF22,
    NR44: 0xFF23,

    NR50: 0xFF24,
    NR51: 0xFF25,
    NR52: 0xFF26
};
GameboyJS.APU = APU;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";
var Channel1 = function(apu, channelNumber, audioContext) {
    this.apu = apu;
    this.channelNumber = channelNumber;
    this.playing = false;

    this.soundLengthUnit = 0x4000; // 1 / 256 second of instructions
    this.soundLength = 64; // defaults to 64 periods
    this.lengthCheck = false;

    this.sweepTime = 0; // from 0 to 7
    this.sweepStepLength = 0x8000; // 1 / 128 seconds of instructions
    this.sweepCount = 0;
    this.sweepShifts = 0;
    this.sweepSign = 1; // +1 / -1 for increase / decrease freq

    this.frequency = 0;

    this.envelopeStep = 0;
    this.envelopeStepLength = 0x10000;// 1 / 64 seconds of instructions
    this.envelopeCheck = false;
    this.envelopeSign = 1;

    this.clockLength = 0;
    this.clockEnvelop = 0;
    this.clockSweep = 0;

    var gainNode = audioContext.createGain();
    gainNode.gain.value = 0;
    var oscillator = audioContext.createOscillator();
    oscillator.type = 'square';
    oscillator.frequency.value = 1000;
    oscillator.connect(gainNode);
    oscillator.start(0);

    this.audioContext = audioContext;
    this.gainNode = gainNode;
    this.oscillator = oscillator;
};

Channel1.prototype.play = function() {
    if (this.playing) return;
    this.playing = true;
    this.apu.setSoundFlag(this.channelNumber, 1);
    this.gainNode.connect(this.audioContext.destination);
    this.clockLength = 0;
    this.clockEnvelop = 0;
    this.clockSweep = 0;
    if (this.sweepShifts > 0) this.checkFreqSweep();
};
Channel1.prototype.stop = function() {
    this.playing = false;
    this.apu.setSoundFlag(this.channelNumber, 0);
    this.gainNode.disconnect();
};
Channel1.prototype.checkFreqSweep = function() {
    var oldFreq = this.getFrequency();
    var newFreq = oldFreq + this.sweepSign * (oldFreq >> this.sweepShifts);
    if (newFreq > 0x7FF) {
        newFreq = 0;
        this.stop();
    }

    return newFreq;
};
Channel1.prototype.update = function(clockElapsed) {
    this.clockEnvelop += clockElapsed;
    this.clockSweep   += clockElapsed;

    if ((this.sweepCount || this.sweepTime) && this.clockSweep > (this.sweepStepLength * this.sweepTime)) {
        this.clockSweep -= (this.sweepStepLength * this.sweepTime);
        this.sweepCount--;

        var newFreq = this.checkFreqSweep(); // process and check new freq

        this.apu.memory[0xFF13] = newFreq & 0xFF;
        this.apu.memory[0xFF14] &= 0xF8;
        this.apu.memory[0xFF14] |= (newFreq & 0x700) >> 8;
        this.setFrequency(newFreq);

        this.checkFreqSweep(); // check again with new value
    }

    if (this.envelopeCheck && this.clockEnvelop > this.envelopeStepLength) {
        this.clockEnvelop -= this.envelopeStepLength;
        this.envelopeStep--;
        this.setEnvelopeVolume(this.envelopeVolume + this.envelopeSign);
        if (this.envelopeStep <= 0) {
            this.envelopeCheck = false;
        }
    }

    if (this.lengthCheck) {
        this.clockLength += clockElapsed;
        if (this.clockLength > this.soundLengthUnit) {
            this.soundLength--;
            this.clockLength -= this.soundLengthUnit;
            if (this.soundLength == 0) {
                this.setLength(0);
                this.stop();
            }
        }
    }
};
Channel1.prototype.setFrequency = function(value) {
    this.frequency = value;
    this.oscillator.frequency.value = 131072 / (2048 - this.frequency);
};
Channel1.prototype.getFrequency = function() {
    return this.frequency;
};
Channel1.prototype.setLength = function(value) {
    this.soundLength = 64 - (value & 0x3F);
};
Channel1.prototype.setEnvelopeVolume = function(volume) {
    this.envelopeCheck = volume > 0 && volume < 16 ? true : false;
    this.envelopeVolume = volume;
    this.gainNode.gain.value = this.envelopeVolume * 1/100;
};
Channel1.prototype.disable = function() {
    this.oscillator.disconnect();
};
Channel1.prototype.enable = function() {
    this.oscillator.connect(this.gainNode);
};
GameboyJS.Channel1 = Channel1;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";
var Channel3 = function(apu, channelNumber, audioContext) {
    this.apu = apu;
    this.channelNumber = channelNumber;
    this.playing = false;

    this.soundLength = 0;
    this.soundLengthUnit = 0x4000; // 1 / 256 second of instructions
    this.lengthCheck = false;

    this.clockLength = 0;

    this.buffer = new Float32Array(32);

    var gainNode = audioContext.createGain();
    gainNode.gain.value = 1;
    this.gainNode = gainNode;

    this.baseSpeed = 65536;
    var waveBuffer = audioContext.createBuffer(1, 32, this.baseSpeed);

    var bufferSource = audioContext.createBufferSource();
    bufferSource.buffer = waveBuffer;
    bufferSource.loop = true;
    bufferSource.connect(gainNode);
    bufferSource.start(0);

    this.audioContext = audioContext;
    this.waveBuffer = waveBuffer;
    this.bufferSource = bufferSource;

};
Channel3.prototype.play = function() {
    if (this.playing) return;
    this.playing = true;
    this.apu.setSoundFlag(this.channelNumber, 1);
    this.waveBuffer.copyToChannel(this.buffer, 0, 0);

    this.gainNode.connect(this.audioContext.destination);
    this.clockLength = 0;
};
Channel3.prototype.stop = function() {
    this.playing = false;
    this.apu.setSoundFlag(this.channelNumber, 0);
    this.gainNode.disconnect();
};
Channel3.prototype.update = function(clockElapsed) {
    if (this.lengthCheck){
        this.clockLength  += clockElapsed;
        if (this.clockLength > this.soundLengthUnit) {
            this.soundLength--;
            this.clockLength -= this.soundLengthUnit;
            if (this.soundLength == 0) {
                this.setLength(0);
                this.stop();
            }
        }
    }
};
Channel3.prototype.setFrequency = function(value) {
    value = 65536 / (2048  - value);
    this.bufferSource.playbackRate.value = value / this.baseSpeed;
};
Channel3.prototype.getFrequency = function() {
    var freq = 2048 - 65536 / (this.bufferSource.playbackRate.value * this.baseSpeed);
    return freq | 1;
};
Channel3.prototype.setLength = function(value) {
    this.soundLength = 256 - value;
};
Channel3.prototype.setWaveBufferByte = function(index, value) {
    var bufferIndex = index * 2;

    this.buffer[bufferIndex]   = (value >> 4) / 8 - 1; // value in buffer is in -1 -> 1
    this.buffer[bufferIndex+1] = (value & 0x0F) / 8 - 1;
};
Channel3.prototype.disable = function() {
    this.bufferSource.disconnect();
};
Channel3.prototype.enable = function() {
    this.bufferSource.connect(this.gainNode);
};
GameboyJS.Channel3 = Channel3;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";
var Channel4 = function(apu, channelNumber, audioContext) {
    this.apu = apu;
    this.channelNumber = channelNumber;
    this.playing = false;

    this.soundLengthUnit = 0x4000; // 1 / 256 second of instructions
    this.soundLength = 64; // defaults to 64 periods
    this.lengthCheck = false;

    this.clockLength = 0;

    this.audioContext = audioContext;
};

Channel4.prototype.play = function() {
    if (this.playing) return;
    this.playing = true;
    this.apu.setSoundFlag(this.channelNumber, 1);
    this.clockLength = 0;
};
Channel4.prototype.stop = function() {
    this.playing = false;
    this.apu.setSoundFlag(this.channelNumber, 0);
};
Channel4.prototype.update = function(clockElapsed) {
    if (this.lengthCheck) {
        this.clockLength  += clockElapsed;
        if (this.clockLength > this.soundLengthUnit) {
            this.soundLength--;
            this.clockLength -= this.soundLengthUnit;
            if (this.soundLength == 0) {
                this.setLength(0);
                this.stop();
            }
        }
    }
};
Channel4.prototype.setLength = function(value) {
    this.soundLength = 64 - (value & 0x3F);
};
GameboyJS.Channel4 = Channel4;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

var Timer = function(cpu, memory) {
    this.cpu    = cpu;
    this.memory = memory;

    this.DIV  = 0xFF04;
    this.TIMA = 0xFF05;
    this.TMA  = 0xFF06;
    this.TAC  = 0xFF07;

    this.mainTime  = 0;
    this.divTime   = 0;
};

Timer.prototype.update = function(clockElapsed) {
    this.updateDiv(clockElapsed);
    this.updateTimer(clockElapsed);
};

Timer.prototype.updateTimer = function(clockElapsed) {
    if (!(this.memory.rb(this.TAC) & 0x4)) {
        return;
    }
    this.mainTime += clockElapsed;

    var threshold = 64;
    switch (this.memory.rb(this.TAC) & 3) {
        case 0: threshold=64; break; // 4KHz
        case 1: threshold=1;  break; // 256KHz
        case 2: threshold=4;  break; // 64KHz
        case 3: threshold=16; break; // 16KHz
    }
    threshold *= 16;

    while (this.mainTime >= threshold) {
        this.mainTime -= threshold;

        this.memory.wb(this.TIMA, this.memory.rb(this.TIMA) + 1);
        if (this.memory.rb(this.TIMA) > 0xFF) {
            this.memory.wb(this.TIMA, this.memory.rb(this.TMA));
            this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.TIMER);
        }
    }
};
// Update the DIV register internal clock
// Increment it if the clock threshold is elapsed and
// reset it if its value overflows
Timer.prototype.updateDiv = function(clockElapsed) {
    var divThreshold = 256; // DIV is 16KHz
    this.divTime += clockElapsed;
    if (this.divTime > divThreshold) {
        this.divTime -= divThreshold;
        var div = this.memory.rb(this.DIV) + 1;
        this.memory.wb(this.DIV, div&0xFF);
    }
};

Timer.prototype.resetDiv = function() {
    this.divTime = 0;
    this.memory[this.DIV] = 0; // direct write to avoid looping
};
GameboyJS.Timer = Timer;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
"use strict";

// Utility functions
var Util = {
    // Add to the first argument the properties of all other arguments
    extend: function(target /*, source1, source2, etc. */) {
        var sources = Array.prototype.slice.call(arguments);
        for (var i in sources) {
            var source = sources[i];
            for (var name in source) {
                target[name] = source[name];
            }
        }

        return target;
    },
    testFlag: function(p, cc) {
        var test=1;
        var mask=0x10;
        if (cc=='NZ'||cc=='NC') test=0;
        if (cc=='NZ'||cc=='Z')  mask=0x80;
        return (test && p.r.F&mask) || (!test && !(p.r.F&mask));
    },
    getRegAddr: function(p, r1, r2) {return Util.makeword(p.r[r1], p.r[r2]);},

    // make a 16 bits word from 2 bytes
    makeword: function(b1, b2) {return (b1 << 8) + b2;},

    // return the integer signed value of a given byte
    getSignedValue: function(v) {return v & 0x80 ? v-256 : v;},

    // extract a bit from a byte
    readBit: function(byte, index) {
        return (byte >> index) & 1;
    }
};

GameboyJS.Util = Util;
}(GameboyJS || (GameboyJS = {})));