text: function MemoryView(memory, offset) {
  	this.inherit();
  	this.buffer = memory;
  	this.view = new DataView(this.buffer, typeof(offset) === "number" ? offset : 0);
  	this.mask = memory.byteLength - 1;
  	this.resetMask();
  };
  
  MemoryView.prototype.resetMask = function() {
  	this.mask8 = this.mask & 0xFFFFFFFF;
  	this.mask16 = this.mask & 0xFFFFFFFE;
  	this.mask32 = this.mask & 0xFFFFFFFC;
  };
  
  MemoryView.prototype.load8 = function(offset) {
  	return this.view.getInt8(offset & this.mask8);
  };
  
  MemoryView.prototype.load16 = function(offset) {
  	// Unaligned 16-bit loads are unpredictable...let's just pretend they work
  	return this.view.getInt16(offset & this.mask, true);
  };
  
  MemoryView.prototype.loadU8 = function(offset) {
  	return this.view.getUint8(offset & this.mask8);
  };
  
  MemoryView.prototype.loadU16 = function(offset) {
  	// Unaligned 16-bit loads are unpredictable...let's just pretend they work
  	return this.view.getUint16(offset & this.mask, true);
  };
  
  MemoryView.prototype.load32 = function(offset) {
  	// Unaligned 32-bit loads are "rotated" so they make some semblance of sense
  	var rotate = (offset & 3) << 3;
  	var mem = this.view.getInt32(offset & this.mask32, true);
  	return (mem >>> rotate) | (mem << (32 - rotate));
  };
  
  MemoryView.prototype.store8 = function(offset, value) {
  	this.view.setInt8(offset & this.mask8, value);
  };
  
  MemoryView.prototype.store16 = function(offset, value) {
  	this.view.setInt16(offset & this.mask16, value, true);
  };
  
  MemoryView.prototype.store32 = function(offset, value) {
  	this.view.setInt32(offset & this.mask32, value, true);
  };
  
  MemoryView.prototype.invalidatePage = function(address) {};
  
  MemoryView.prototype.replaceData = function(memory, offset) {
  	this.buffer = memory;
  	this.view = new DataView(this.buffer, typeof(offset) === "number" ? offset : 0);
  	if (this.icache) {
  		this.icache = new Array(this.icache.length);
  	}
  };
  
  function MemoryBlock(size, cacheBits) {
  	MemoryView.call(this, new ArrayBuffer(size));
  	this.ICACHE_PAGE_BITS = cacheBits;
  	this.PAGE_MASK = (2 << this.ICACHE_PAGE_BITS) - 1;
  	this.icache = new Array(size >> (this.ICACHE_PAGE_BITS + 1));
  };
  
  MemoryBlock.prototype = Object.create(MemoryView.prototype);
  
  MemoryBlock.prototype.invalidatePage = function(address) {
  	var page = this.icache[(address & this.mask) >> this.ICACHE_PAGE_BITS];
  	if (page) {
  		page.invalid = true;
  	}
  };
  
  function ROMView(rom, offset) {
  	MemoryView.call(this, rom, offset);
  	this.ICACHE_PAGE_BITS = 10;
  	this.PAGE_MASK = (2 << this.ICACHE_PAGE_BITS) - 1;
  	this.icache = new Array(rom.byteLength >> (this.ICACHE_PAGE_BITS + 1));
  	this.mask = 0x01FFFFFF;
  	this.resetMask();
  };
  
  ROMView.prototype = Object.create(MemoryView.prototype);
  
  ROMView.prototype.store8 = function(offset, value) {};
  
  ROMView.prototype.store16 = function(offset, value) {
  	if (offset < 0xCA && offset >= 0xC4) {
  		if (!this.gpio) {
  			this.gpio = this.mmu.allocGPIO(this);
  		}
  		this.gpio.store16(offset, value);
  	}
  };
  
  ROMView.prototype.store32 = function(offset, value) {
  	if (offset < 0xCA && offset >= 0xC4) {
  		if (!this.gpio) {
  			this.gpio = this.mmu.allocGPIO(this);
  		}
  		this.gpio.store32(offset, value);
  	}
  };
  
  function BIOSView(rom, offset) {
  	MemoryView.call(this, rom, offset);
  	this.ICACHE_PAGE_BITS = 16;
  	this.PAGE_MASK = (2 << this.ICACHE_PAGE_BITS) - 1;
  	this.icache = new Array(1);
  };
  
  BIOSView.prototype = Object.create(MemoryView.prototype);
  
  BIOSView.prototype.load8 = function(offset) {
  	if (offset >= this.buffer.byteLength) {
  		return -1;
  	}
  	return this.view.getInt8(offset);
  };
  
  BIOSView.prototype.load16 = function(offset) {
  	if (offset >= this.buffer.byteLength) {
  		return -1;
  	}
  	return this.view.getInt16(offset, true);
  };
  
  BIOSView.prototype.loadU8 = function(offset) {
  	if (offset >= this.buffer.byteLength) {
  		return -1;
  	}
  	return this.view.getUint8(offset);
  };
  
  BIOSView.prototype.loadU16 = function(offset) {
  	if (offset >= this.buffer.byteLength) {
  		return -1;
  	}
  	return this.view.getUint16(offset, true);
  };
  
  BIOSView.prototype.load32 = function(offset) {
  	if (offset >= this.buffer.byteLength) {
  		return -1;
  	}
  	return this.view.getInt32(offset, true);
  };
  
  BIOSView.prototype.store8 = function(offset, value) {};
  
  BIOSView.prototype.store16 = function(offset, value) {};
  
  BIOSView.prototype.store32 = function(offset, value) {};
  
  function BadMemory(mmu, cpu) {
  	this.inherit();
  	this.cpu = cpu;
  	this.mmu = mmu
  };
  
  BadMemory.prototype.load8 = function(offset) {
  	return this.mmu.load8(this.cpu.gprs[this.cpu.PC] - this.cpu.instructionWidth + (offset & 0x3));
  };
  
  BadMemory.prototype.load16 = function(offset) {
  	return this.mmu.load16(this.cpu.gprs[this.cpu.PC] - this.cpu.instructionWidth + (offset & 0x2));
  };
  
  BadMemory.prototype.loadU8 = function(offset) {
  	return this.mmu.loadU8(this.cpu.gprs[this.cpu.PC] - this.cpu.instructionWidth + (offset & 0x3));
  };
  
  BadMemory.prototype.loadU16 = function(offset) {
  	return this.mmu.loadU16(this.cpu.gprs[this.cpu.PC] - this.cpu.instructionWidth + (offset & 0x2));
  };
  
  BadMemory.prototype.load32 = function(offset) {
  	if (this.cpu.execMode == this.cpu.MODE_ARM) {
  		return this.mmu.load32(this.cpu.gprs[this.cpu.gprs.PC] - this.cpu.instructionWidth);
  	} else {
  		var halfword = this.mmu.loadU16(this.cpu.gprs[this.cpu.PC] - this.cpu.instructionWidth);
  		return halfword | (halfword << 16);
  	}
  };
  
  BadMemory.prototype.store8 = function(offset, value) {};
  
  BadMemory.prototype.store16 = function(offset, value) {};
  
  BadMemory.prototype.store32 = function(offset, value) {};
  
  BadMemory.prototype.invalidatePage = function(address) {};
  
  function GameBoyAdvanceMMU() {
  	this.inherit();
  	this.REGION_BIOS = 0x0;
  	this.REGION_WORKING_RAM = 0x2;
  	this.REGION_WORKING_IRAM = 0x3;
  	this.REGION_IO = 0x4;
  	this.REGION_PALETTE_RAM = 0x5;
  	this.REGION_VRAM = 0x6;
  	this.REGION_OAM = 0x7;
  	this.REGION_CART0 = 0x8;
  	this.REGION_CART1 = 0xA;
  	this.REGION_CART2 = 0xC;
  	this.REGION_CART_SRAM = 0xE;
  
  	this.BASE_BIOS = 0x00000000;
  	this.BASE_WORKING_RAM = 0x02000000;
  	this.BASE_WORKING_IRAM = 0x03000000;
  	this.BASE_IO = 0x04000000;
  	this.BASE_PALETTE_RAM = 0x05000000;
  	this.BASE_VRAM = 0x06000000;
  	this.BASE_OAM = 0x07000000;
  	this.BASE_CART0 = 0x08000000;
  	this.BASE_CART1 = 0x0A000000;
  	this.BASE_CART2 = 0x0C000000;
  	this.BASE_CART_SRAM = 0x0E000000;
  
  	this.BASE_MASK = 0x0F000000;
  	this.BASE_OFFSET = 24;
  	this.OFFSET_MASK = 0x00FFFFFF;
  
  	this.SIZE_BIOS = 0x00004000;
  	this.SIZE_WORKING_RAM = 0x00040000;
  	this.SIZE_WORKING_IRAM = 0x00008000;
  	this.SIZE_IO = 0x00000400;
  	this.SIZE_PALETTE_RAM = 0x00000400;
  	this.SIZE_VRAM = 0x00018000;
  	this.SIZE_OAM = 0x00000400;
  	this.SIZE_CART0 = 0x02000000;
  	this.SIZE_CART1 = 0x02000000;
  	this.SIZE_CART2 = 0x02000000;
  	this.SIZE_CART_SRAM = 0x00008000;
  	this.SIZE_CART_FLASH512 = 0x00010000;
  	this.SIZE_CART_FLASH1M = 0x00020000;
  	this.SIZE_CART_EEPROM = 0x00002000;
  
  	this.DMA_TIMING_NOW = 0;
  	this.DMA_TIMING_VBLANK = 1;
  	this.DMA_TIMING_HBLANK = 2;
  	this.DMA_TIMING_CUSTOM = 3;
  
  	this.DMA_INCREMENT = 0;
  	this.DMA_DECREMENT = 1;
  	this.DMA_FIXED = 2;
  	this.DMA_INCREMENT_RELOAD = 3;
  
  	this.DMA_OFFSET = [ 1, -1, 0, 1 ];
  
  	this.WAITSTATES = [ 0, 0, 2, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4 ];
  	this.WAITSTATES_32 = [ 0, 0, 5, 0, 0, 1, 0, 1, 7, 7, 9, 9, 13, 13, 8 ];
  	this.WAITSTATES_SEQ = [ 0, 0, 2, 0, 0, 0, 0, 0, 2, 2, 4, 4, 8, 8, 4 ];
  	this.WAITSTATES_SEQ_32 = [ 0, 0, 5, 0, 0, 1, 0, 1, 5, 5, 9, 9, 17, 17, 8 ];
  	this.NULLWAIT = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
  
  	for (var i = 15; i < 256; ++i) {
  		this.WAITSTATES[i] = 0;
  		this.WAITSTATES_32[i] = 0;
  		this.WAITSTATES_SEQ[i] = 0;
  		this.WAITSTATES_SEQ_32[i] = 0;
  		this.NULLWAIT[i] = 0;
  	}
  
  	this.ROM_WS = [ 4, 3, 2, 8 ];
  	this.ROM_WS_SEQ = [
  		[ 2, 1 ],
  		[ 4, 1 ],
  		[ 8, 1 ]
  	];
  
  	this.ICACHE_PAGE_BITS = 8;
  	this.PAGE_MASK = (2 << this.ICACHE_PAGE_BITS) - 1;
  
  	this.bios = null;
  };
  
  GameBoyAdvanceMMU.prototype.mmap = function(region, object) {
  	this.memory[region] = object;
  }
  
  GameBoyAdvanceMMU.prototype.clear = function() {
  	this.badMemory = new BadMemory(this, this.cpu);
  	this.memory = [
  		this.bios,
  		this.badMemory, // Unused
  		new MemoryBlock(this.SIZE_WORKING_RAM, 9),
  		new MemoryBlock(this.SIZE_WORKING_IRAM, 7),
  		null, // This is owned by GameBoyAdvanceIO
  		null, // This is owned by GameBoyAdvancePalette
  		null, // This is owned by GameBoyAdvanceVRAM
  		null, // This is owned by GameBoyAdvanceOAM
  		this.badMemory,
  		this.badMemory,
  		this.badMemory,
  		this.badMemory,
  		this.badMemory,
  		this.badMemory,
  		this.badMemory,
  		this.badMemory // Unused
  	];
  	for (var i = 16; i < 256; ++i) {
  		this.memory[i] = this.badMemory;
  	}
  
  	this.waitstates = this.WAITSTATES.slice(0);
  	this.waitstatesSeq = this.WAITSTATES_SEQ.slice(0);
  	this.waitstates32 = this.WAITSTATES_32.slice(0);
  	this.waitstatesSeq32 = this.WAITSTATES_SEQ_32.slice(0);
  	this.waitstatesPrefetch = this.WAITSTATES_SEQ.slice(0);
  	this.waitstatesPrefetch32 = this.WAITSTATES_SEQ_32.slice(0);
  
  	this.cart = null;
  	this.save = null;
  
  	this.DMA_REGISTER = [
  		this.core.io.DMA0CNT_HI >> 1,
  		this.core.io.DMA1CNT_HI >> 1,
  		this.core.io.DMA2CNT_HI >> 1,
  		this.core.io.DMA3CNT_HI >> 1
  	];
  };
  
  GameBoyAdvanceMMU.prototype.freeze = function() {
  	return {
  		'ram': Serializer.prefix(this.memory[this.REGION_WORKING_RAM].buffer),
  		'iram': Serializer.prefix(this.memory[this.REGION_WORKING_IRAM].buffer),
  	};
  };
  
  GameBoyAdvanceMMU.prototype.defrost = function(frost) {
  	this.memory[this.REGION_WORKING_RAM].replaceData(frost.ram);
  	this.memory[this.REGION_WORKING_IRAM].replaceData(frost.iram);
  };
  
  GameBoyAdvanceMMU.prototype.loadBios = function(bios, real) {
  	this.bios = new BIOSView(bios);
  	this.bios.real = !!real;
  };
  
  GameBoyAdvanceMMU.prototype.loadRom = function(rom, process) {
  	var cart = {
  		title: null,
  		code: null,
  		maker: null,
  		memory: rom,
  		saveType: null,
  	};
  
  	var lo = new ROMView(rom);
  	if (lo.view.getUint8(0xB2) != 0x96) {
  		// Not a valid ROM
  		return null;
  	}
  	lo.mmu = this; // Needed for GPIO
  	this.memory[this.REGION_CART0] = lo;
  	this.memory[this.REGION_CART1] = lo;
  	this.memory[this.REGION_CART2] = lo;
  
  	if (rom.byteLength > 0x01000000) {
  		var hi = new ROMView(rom, 0x01000000);
  		this.memory[this.REGION_CART0 + 1] = hi;
  		this.memory[this.REGION_CART1 + 1] = hi;
  		this.memory[this.REGION_CART2 + 1] = hi;
  	}
  
  	if (process) {
  		var name = '';
  		for (var i = 0; i < 12; ++i) {
  			var c = lo.loadU8(i + 0xA0);
  			if (!c) {
  				break;
  			}
  			name += String.fromCharCode(c);
  		}
  		cart.title = name;
  
  		var code = '';
  		for (var i = 0; i < 4; ++i) {
  			var c = lo.loadU8(i + 0xAC);
  			if (!c) {
  				break;
  			}
  			code += String.fromCharCode(c);
  		}
  		cart.code = code;
  
  		var maker = '';
  		for (var i = 0; i < 2; ++i) {
  			var c = lo.loadU8(i + 0xB0);
  			if (!c) {
  				break;
  			}
  			maker += String.fromCharCode(c);
  		}
  		cart.maker = maker;
  
  		// Find savedata type
  		var state = '';
  		var next;
  		var terminal = false;
  		for (var i = 0xE4; i < rom.byteLength && !terminal; ++i) {
  			next = String.fromCharCode(lo.loadU8(i));
  			state += next;
  			switch (state) {
  			case 'F':
  			case 'FL':
  			case 'FLA':
  			case 'FLAS':
  			case 'FLASH':
  			case 'FLASH_':
  			case 'FLASH5':
  			case 'FLASH51':
  			case 'FLASH512':
  			case 'FLASH512_':
  			case 'FLASH1':
  			case 'FLASH1M':
  			case 'FLASH1M_':
  			case 'S':
  			case 'SR':
  			case 'SRA':
  			case 'SRAM':
  			case 'SRAM_':
  			case 'E':
  			case 'EE':
  			case 'EEP':
  			case 'EEPR':
  			case 'EEPRO':
  			case 'EEPROM':
  			case 'EEPROM_':
  				break;
  			case 'FLASH_V':
  			case 'FLASH512_V':
  			case 'FLASH1M_V':
  			case 'SRAM_V':
  			case 'EEPROM_V':
  				terminal = true;
  				break;
  			default:
  				state = next;
  				break;
  			}
  		}
  		if (terminal) {
  			cart.saveType = state;
  			switch (state) {
  			case 'FLASH_V':
  			case 'FLASH512_V':
  				this.save = this.memory[this.REGION_CART_SRAM] = new FlashSavedata(this.SIZE_CART_FLASH512);
  				break;
  			case 'FLASH1M_V':
  				this.save = this.memory[this.REGION_CART_SRAM] = new FlashSavedata(this.SIZE_CART_FLASH1M);
  				break;
  			case 'SRAM_V':
  				this.save = this.memory[this.REGION_CART_SRAM] = new SRAMSavedata(this.SIZE_CART_SRAM);
  				break;
  			case 'EEPROM_V':
  				this.save = this.memory[this.REGION_CART2 + 1] = new EEPROMSavedata(this.SIZE_CART_EEPROM, this);
  				break;
  			}
  		}
  		if (!this.save) {
  			// Assume we have SRAM
  			this.save = this.memory[this.REGION_CART_SRAM] = new SRAMSavedata(this.SIZE_CART_SRAM);
  		}
  	}
  
  	this.cart = cart;
  	return cart;
  };
  
  GameBoyAdvanceMMU.prototype.loadSavedata = function(save) {
  	this.save.replaceData(save);
  };
  
  GameBoyAdvanceMMU.prototype.load8 = function(offset) {
  	return this.memory[offset >>> this.BASE_OFFSET].load8(offset & 0x00FFFFFF);
  };
  
  GameBoyAdvanceMMU.prototype.load16 = function(offset) {
  	return this.memory[offset >>> this.BASE_OFFSET].load16(offset & 0x00FFFFFF);
  };
  
  GameBoyAdvanceMMU.prototype.load32 = function(offset) {
  	return this.memory[offset >>> this.BASE_OFFSET].load32(offset & 0x00FFFFFF);
  };
  
  GameBoyAdvanceMMU.prototype.loadU8 = function(offset) {
  	return this.memory[offset >>> this.BASE_OFFSET].loadU8(offset & 0x00FFFFFF);
  };
  
  GameBoyAdvanceMMU.prototype.loadU16 = function(offset) {
  	return this.memory[offset >>> this.BASE_OFFSET].loadU16(offset & 0x00FFFFFF);
  };
  
  GameBoyAdvanceMMU.prototype.store8 = function(offset, value) {
  	var maskedOffset = offset & 0x00FFFFFF;
  	var memory = this.memory[offset >>> this.BASE_OFFSET];
  	memory.store8(maskedOffset, value);
  	memory.invalidatePage(maskedOffset);
  };
  
  GameBoyAdvanceMMU.prototype.store16 = function(offset, value) {
  	var maskedOffset = offset & 0x00FFFFFE;
  	var memory = this.memory[offset >>> this.BASE_OFFSET];
  	memory.store16(maskedOffset, value);
  	memory.invalidatePage(maskedOffset);
  };
  
  GameBoyAdvanceMMU.prototype.store32 = function(offset, value) {
  	var maskedOffset = offset & 0x00FFFFFC;
  	var memory = this.memory[offset >>> this.BASE_OFFSET];
  	memory.store32(maskedOffset, value);
  	memory.invalidatePage(maskedOffset);
  	memory.invalidatePage(maskedOffset + 2);
  };
  
  GameBoyAdvanceMMU.prototype.waitPrefetch = function(memory) {
  	this.cpu.cycles += 1 + this.waitstatesPrefetch[memory >>> this.BASE_OFFSET];
  };
  
  GameBoyAdvanceMMU.prototype.waitPrefetch32 = function(memory) {
  	this.cpu.cycles += 1 + this.waitstatesPrefetch32[memory >>> this.BASE_OFFSET];
  };
  
  GameBoyAdvanceMMU.prototype.wait = function(memory) {
  	this.cpu.cycles += 1 + this.waitstates[memory >>> this.BASE_OFFSET];
  };
  
  GameBoyAdvanceMMU.prototype.wait32 = function(memory) {
  	this.cpu.cycles += 1 + this.waitstates32[memory >>> this.BASE_OFFSET];
  };
  
  GameBoyAdvanceMMU.prototype.waitSeq = function(memory) {
  	this.cpu.cycles += 1 + this.waitstatesSeq[memory >>> this.BASE_OFFSET];
  };
  
  GameBoyAdvanceMMU.prototype.waitSeq32 = function(memory) {
  	this.cpu.cycles += 1 + this.waitstatesSeq32[memory >>> this.BASE_OFFSET];
  };
  
  GameBoyAdvanceMMU.prototype.waitMul = function(rs) {
  	if ((rs & 0xFFFFFF00 == 0xFFFFFF00) || !(rs & 0xFFFFFF00)) {
  		this.cpu.cycles += 1;
  	} else if ((rs & 0xFFFF0000 == 0xFFFF0000) || !(rs & 0xFFFF0000)) {
  		this.cpu.cycles += 2;
  	} else if ((rs & 0xFF000000 == 0xFF000000) || !(rs & 0xFF000000)) {
  		this.cpu.cycles += 3;
  	} else {
  		this.cpu.cycles += 4;
  	}
  }
  
  GameBoyAdvanceMMU.prototype.waitMulti32 = function(memory, seq) {
  	this.cpu.cycles += 1 + this.waitstates32[memory >>> this.BASE_OFFSET];
  	this.cpu.cycles += (1 + this.waitstatesSeq32[memory >>> this.BASE_OFFSET]) * (seq - 1);
  };
  
  GameBoyAdvanceMMU.prototype.addressToPage = function(region, address) {
  	return address >> this.memory[region].ICACHE_PAGE_BITS;
  };
  
  GameBoyAdvanceMMU.prototype.accessPage = function(region, pageId) {
  	var memory = this.memory[region];
  	var page = memory.icache[pageId];
  	if (!page || page.invalid) {
  		page = {
  			thumb: new Array(1 << (memory.ICACHE_PAGE_BITS)),
  			arm: new Array(1 << memory.ICACHE_PAGE_BITS - 1),
  			invalid: false
  		}
  		memory.icache[pageId] = page;
  	}
  	return page;
  };
  
  GameBoyAdvanceMMU.prototype.scheduleDma = function(number, info) {
  	switch (info.timing) {
  	case this.DMA_TIMING_NOW:
  		this.serviceDma(number, info);
  		break;
  	case this.DMA_TIMING_HBLANK:
  		// Handled implicitly
  		break;
  	case this.DMA_TIMING_VBLANK:
  		// Handled implicitly
  		break;
  	case this.DMA_TIMING_CUSTOM:
  		switch (number) {
  		case 0:
  			this.core.WARN('Discarding invalid DMA0 scheduling');
  			break;
  		case 1:
  		case 2:
  			this.cpu.irq.audio.scheduleFIFODma(number, info);
  			break;
  		case 3:
  			this.cpu.irq.video.scheduleVCaptureDma(dma, info);
  			break;
  		}
  	}
  };
  
  GameBoyAdvanceMMU.prototype.runHblankDmas = function() {
  	var dma;
  	for (var i = 0; i < this.cpu.irq.dma.length; ++i) {
  		dma = this.cpu.irq.dma[i];
  		if (dma.enable && dma.timing == this.DMA_TIMING_HBLANK) {
  			this.serviceDma(i, dma);
  		}
  	}
  };
  
  GameBoyAdvanceMMU.prototype.runVblankDmas = function() {
  	var dma;
  	for (var i = 0; i < this.cpu.irq.dma.length; ++i) {
  		dma = this.cpu.irq.dma[i];
  		if (dma.enable && dma.timing == this.DMA_TIMING_VBLANK) {
  			this.serviceDma(i, dma);
  		}
  	}
  };
  
  GameBoyAdvanceMMU.prototype.serviceDma = function(number, info) {
  	if (!info.enable) {
  		// There was a DMA scheduled that got canceled
  		return;
  	}
  
  	var width = info.width;
  	var sourceOffset = this.DMA_OFFSET[info.srcControl] * width;
  	var destOffset = this.DMA_OFFSET[info.dstControl] * width;
  	var wordsRemaining = info.nextCount;
  	var source = info.nextSource & this.OFFSET_MASK;
  	var dest = info.nextDest & this.OFFSET_MASK;
  	var sourceRegion = info.nextSource >>> this.BASE_OFFSET;
  	var destRegion = info.nextDest >>> this.BASE_OFFSET;
  	var sourceBlock = this.memory[sourceRegion];
  	var destBlock = this.memory[destRegion];
  	var sourceView = null;
  	var destView = null;
  	var sourceMask = 0xFFFFFFFF;
  	var destMask = 0xFFFFFFFF;
  	var word;
  
  	if (destBlock.ICACHE_PAGE_BITS) {
  		var endPage = (dest + wordsRemaining * width) >> destBlock.ICACHE_PAGE_BITS;
  		for (var i = dest >> destBlock.ICACHE_PAGE_BITS; i <= endPage; ++i) {
  			destBlock.invalidatePage(i << destBlock.ICACHE_PAGE_BITS);
  		}
  	}
  
  	if (destRegion == this.REGION_WORKING_RAM || destRegion == this.REGION_WORKING_IRAM) {
  		destView = destBlock.view;
  		destMask = destBlock.mask;
  	}
  
  	if (sourceRegion == this.REGION_WORKING_RAM || sourceRegion == this.REGION_WORKING_IRAM || sourceRegion == this.REGION_CART0 || sourceRegion == this.REGION_CART1) {
  		sourceView = sourceBlock.view;
  		sourceMask = sourceBlock.mask;
  	}
  
  	if (sourceBlock && destBlock) {
  		if (sourceView && destView) {
  			if (width == 4) {
  				source &= 0xFFFFFFFC;
  				dest &= 0xFFFFFFFC;
  				while (wordsRemaining--) {
  					word = sourceView.getInt32(source & sourceMask);
  					destView.setInt32(dest & destMask, word);
  					source += sourceOffset;
  					dest += destOffset;
  				}
  			} else {
  				while (wordsRemaining--) {
  					word = sourceView.getUint16(source & sourceMask);
  					destView.setUint16(dest & destMask, word);
  					source += sourceOffset;
  					dest += destOffset;
  				}
  			}
  		} else if (sourceView) {
  			if (width == 4) {
  				source &= 0xFFFFFFFC;
  				dest &= 0xFFFFFFFC;
  				while (wordsRemaining--) {
  					word = sourceView.getInt32(source & sourceMask, true);
  					destBlock.store32(dest, word);
  					source += sourceOffset;
  					dest += destOffset;
  				}
  			} else {
  				while (wordsRemaining--) {
  					word = sourceView.getUint16(source & sourceMask, true);
  					destBlock.store16(dest, word);
  					source += sourceOffset;
  					dest += destOffset;
  				}
  			}
  		} else {
  			if (width == 4) {
  				source &= 0xFFFFFFFC;
  				dest &= 0xFFFFFFFC;
  				while (wordsRemaining--) {
  					word = sourceBlock.load32(source);
  					destBlock.store32(dest, word);
  					source += sourceOffset;
  					dest += destOffset;
  				}
  			} else {
  				while (wordsRemaining--) {
  					word = sourceBlock.loadU16(source);
  					destBlock.store16(dest, word);
  					source += sourceOffset;
  					dest += destOffset;
  				}
  			}
  		}
  	} else {
  		this.core.WARN('Invalid DMA');
  	}
  
  	if (info.doIrq) {
  		info.nextIRQ = this.cpu.cycles + 2;
  		info.nextIRQ += (width == 4 ? this.waitstates32[sourceRegion] + this.waitstates32[destRegion]
  		                            : this.waitstates[sourceRegion] + this.waitstates[destRegion]);
  		info.nextIRQ += (info.count - 1) * (width == 4 ? this.waitstatesSeq32[sourceRegion] + this.waitstatesSeq32[destRegion]
  		                                               : this.waitstatesSeq[sourceRegion] + this.waitstatesSeq[destRegion]);
  	}
  
  	info.nextSource = source | (sourceRegion << this.BASE_OFFSET);
  	info.nextDest = dest | (destRegion << this.BASE_OFFSET);
  	info.nextCount = wordsRemaining;
  
  	if (!info.repeat) {
  		info.enable = false;
  
  		// Clear the enable bit in memory
  		var io = this.memory[this.REGION_IO];
  		io.registers[this.DMA_REGISTER[number]] &= 0x7FE0;
  	} else {
  		info.nextCount = info.count;
  		if (info.dstControl == this.DMA_INCREMENT_RELOAD) {
  			info.nextDest = info.dest;
  		}
  		this.scheduleDma(number, info);
  	}
  };
  
  GameBoyAdvanceMMU.prototype.adjustTimings = function(word) {
  	var sram = word & 0x0003;
  	var ws0 = (word & 0x000C) >> 2;
  	var ws0seq = (word & 0x0010) >> 4;
  	var ws1 = (word & 0x0060) >> 5;
  	var ws1seq = (word & 0x0080) >> 7;
  	var ws2 = (word & 0x0300) >> 8;
  	var ws2seq = (word & 0x0400) >> 10;
  	var prefetch = word & 0x4000;
  
  	this.waitstates[this.REGION_CART_SRAM] = this.ROM_WS[sram];
  	this.waitstatesSeq[this.REGION_CART_SRAM] = this.ROM_WS[sram];
  	this.waitstates32[this.REGION_CART_SRAM] = this.ROM_WS[sram];
  	this.waitstatesSeq32[this.REGION_CART_SRAM] = this.ROM_WS[sram];
  
  	this.waitstates[this.REGION_CART0] = this.waitstates[this.REGION_CART0 + 1] = this.ROM_WS[ws0];
  	this.waitstates[this.REGION_CART1] = this.waitstates[this.REGION_CART1 + 1] = this.ROM_WS[ws1];
  	this.waitstates[this.REGION_CART2] = this.waitstates[this.REGION_CART2 + 1] = this.ROM_WS[ws2];
  
  	this.waitstatesSeq[this.REGION_CART0] = this.waitstatesSeq[this.REGION_CART0 + 1] = this.ROM_WS_SEQ[0][ws0seq];
  	this.waitstatesSeq[this.REGION_CART1] = this.waitstatesSeq[this.REGION_CART1 + 1] = this.ROM_WS_SEQ[1][ws1seq];
  	this.waitstatesSeq[this.REGION_CART2] = this.waitstatesSeq[this.REGION_CART2 + 1] = this.ROM_WS_SEQ[2][ws2seq];
  
  	this.waitstates32[this.REGION_CART0] = this.waitstates32[this.REGION_CART0 + 1] = this.waitstates[this.REGION_CART0] + 1 + this.waitstatesSeq[this.REGION_CART0];
  	this.waitstates32[this.REGION_CART1] = this.waitstates32[this.REGION_CART1 + 1] = this.waitstates[this.REGION_CART1] + 1 + this.waitstatesSeq[this.REGION_CART1];
  	this.waitstates32[this.REGION_CART2] = this.waitstates32[this.REGION_CART2 + 1] = this.waitstates[this.REGION_CART2] + 1 + this.waitstatesSeq[this.REGION_CART2];
  
  	this.waitstatesSeq32[this.REGION_CART0] = this.waitstatesSeq32[this.REGION_CART0 + 1] = 2 * this.waitstatesSeq[this.REGION_CART0] + 1;
  	this.waitstatesSeq32[this.REGION_CART1] = this.waitstatesSeq32[this.REGION_CART1 + 1] = 2 * this.waitstatesSeq[this.REGION_CART1] + 1;
  	this.waitstatesSeq32[this.REGION_CART2] = this.waitstatesSeq32[this.REGION_CART2 + 1] = 2 * this.waitstatesSeq[this.REGION_CART2] + 1;
  
  	if (prefetch) {
  		this.waitstatesPrefetch[this.REGION_CART0] = this.waitstatesPrefetch[this.REGION_CART0 + 1] = 0;
  		this.waitstatesPrefetch[this.REGION_CART1] = this.waitstatesPrefetch[this.REGION_CART1 + 1] = 0;
  		this.waitstatesPrefetch[this.REGION_CART2] = this.waitstatesPrefetch[this.REGION_CART2 + 1] = 0;
  
  		this.waitstatesPrefetch32[this.REGION_CART0] = this.waitstatesPrefetch32[this.REGION_CART0 + 1] = 0;
  		this.waitstatesPrefetch32[this.REGION_CART1] = this.waitstatesPrefetch32[this.REGION_CART1 + 1] = 0;
  		this.waitstatesPrefetch32[this.REGION_CART2] = this.waitstatesPrefetch32[this.REGION_CART2 + 1] = 0;
  	} else {
  		this.waitstatesPrefetch[this.REGION_CART0] = this.waitstatesPrefetch[this.REGION_CART0 + 1] = this.waitstatesSeq[this.REGION_CART0];
  		this.waitstatesPrefetch[this.REGION_CART1] = this.waitstatesPrefetch[this.REGION_CART1 + 1] = this.waitstatesSeq[this.REGION_CART1];
  		this.waitstatesPrefetch[this.REGION_CART2] = this.waitstatesPrefetch[this.REGION_CART2 + 1] = this.waitstatesSeq[this.REGION_CART2];
  
  		this.waitstatesPrefetch32[this.REGION_CART0] = this.waitstatesPrefetch32[this.REGION_CART0 + 1] = this.waitstatesSeq32[this.REGION_CART0];
  		this.waitstatesPrefetch32[this.REGION_CART1] = this.waitstatesPrefetch32[this.REGION_CART1 + 1] = this.waitstatesSeq32[this.REGION_CART1];
  		this.waitstatesPrefetch32[this.REGION_CART2] = this.waitstatesPrefetch32[this.REGION_CART2 + 1] = this.waitstatesSeq32[this.REGION_CART2];
  	}
  };
  
  GameBoyAdvanceMMU.prototype.saveNeedsFlush = function() {
  	return this.save.writePending;
  };
  
  GameBoyAdvanceMMU.prototype.flushSave = function() {
  	this.save.writePending = false;
  };
  
  GameBoyAdvanceMMU.prototype.allocGPIO = function(rom) {
  	return new GameBoyAdvanceGPIO(this.core, rom);
  };
  