BizHawk/ExternalCoreProjects/Virtu/Memory.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace Jellyfish.Virtu
{
	// ReSharper disable once UnusedMember.Global
	public enum MonitorType { Unknown, Standard, Enhanced }

	public interface IMemoryBus
	{
		// ReSharper disable once UnusedMemberInSuper.Global
		bool Lagged { get; }

		int ReadRomRegionE0FF(int address);
		int ReadRamMainRegion02BF(int address);
		int ReadRamAuxRegion02BF(int address);

		int Read(int address);
		int Peek(int address);
		int ReadOpcode(int address);
		int ReadZeroPage(int address);
		void WriteZeroPage(int address, int data);
		void Write(int address, int data);

		bool IsText { get; }
		bool IsMixed { get; }
		bool IsHires { get; }
		bool IsVideoPage2 { get; }
		bool IsCharSetAlternate { get; }

		int VideoMode { get; }
		MonitorType Monitor { get; }

		// ReSharper disable once UnusedMember.Global
		void Sync(IComponentSerializer ser);
	}

	// ReSharper disable once UnusedMember.Global
	public sealed partial class Memory : IMemoryBus
	{
		private IGamePort _gamePort;
		private ICassette _cassette;
		private IVideo _video;
		private ISlotClock _noSlotClock;

		private IPeripheralCard _slot1;
		private IPeripheralCard _slot2;
		private IPeripheralCard _slot3;
		private IPeripheralCard _slot4;
		private IPeripheralCard _slot5;
		private IPeripheralCard _slot7;

		private readonly byte[] _appleIIe;
		private readonly byte[][] _regionRead = new byte[RegionCount][];
		private readonly byte[][] _regionWrite = new byte[RegionCount][];
		private readonly Action<int, byte>[] _writeRegion = new Action<int, byte>[RegionCount];

		private bool _lagged;
		private int _state;
		private int _slotRegionC8CF;
		private byte[] _zeroPage;
		private byte[] _ramMainRegion0001 = new byte[0x0200];
		private byte[] _ramMainRegion02BF = new byte[0xBE00];
		private byte[] _ramMainBank1RegionD0DF = new byte[0x1000];
		private byte[] _ramMainBank2RegionD0DF = new byte[0x1000];
		private byte[] _ramMainRegionE0FF = new byte[0x2000];
		private byte[] _ramAuxRegion0001 = new byte[0x0200];
		private byte[] _ramAuxRegion02BF = new byte[0xBE00];
		private byte[] _ramAuxBank1RegionD0DF = new byte[0x1000];
		private byte[] _ramAuxBank2RegionD0DF = new byte[0x1000];
		private byte[] _ramAuxRegionE0FF = new byte[0x2000];

		private byte[] _romExternalRegionC1CF = new byte[0x0F00];
		private byte[] _romInternalRegionC1CF = new byte[0x0F00];
		private byte[] _romRegionD0DF = new byte[0x1000];
		private byte[] _romRegionE0FF = new byte[0x2000];

		// ReSharper disable once UnusedMember.Global
		public Memory(byte[] appleIIe)
		{
			_appleIIe = appleIIe;
			InitializeWriteDelegates();
		}

		public void Sync(IComponentSerializer ser)
		{
			ser.Sync(nameof(_lagged), ref _lagged);
			ser.Sync(nameof(_state), ref _state);
			ser.Sync(nameof(_slotRegionC8CF), ref _slotRegionC8CF);
			ser.Sync(nameof(_zeroPage), ref _zeroPage, false);

			ser.Sync(nameof(_ramMainRegion0001), ref _ramMainRegion0001, false);
			ser.Sync(nameof(_ramMainRegion02BF), ref _ramMainRegion02BF, false);
			ser.Sync(nameof(_ramMainBank1RegionD0DF), ref _ramMainBank1RegionD0DF, false);
			ser.Sync(nameof(_ramMainBank2RegionD0DF), ref _ramMainBank2RegionD0DF, false);
			ser.Sync(nameof(_ramMainRegionE0FF), ref _ramMainRegionE0FF, false);
			ser.Sync(nameof(_ramAuxRegion0001), ref _ramAuxRegion0001, false);
			ser.Sync(nameof(_ramAuxRegion02BF), ref _ramAuxRegion02BF, false);
			ser.Sync(nameof(_ramAuxBank1RegionD0DF), ref _ramAuxBank1RegionD0DF, false);
			ser.Sync(nameof(_ramAuxBank2RegionD0DF), ref _ramAuxBank2RegionD0DF, false);
			ser.Sync(nameof(_ramAuxRegionE0FF), ref _ramAuxRegionE0FF, false);
			ser.Sync(nameof(_romExternalRegionC1CF), ref _romExternalRegionC1CF, false);
			ser.Sync(nameof(_romInternalRegionC1CF), ref _romInternalRegionC1CF, false);
			ser.Sync(nameof(_romRegionD0DF), ref _romRegionD0DF, false);
			ser.Sync(nameof(_romRegionE0FF), ref _romRegionE0FF, false);

			if (ser.IsReader)
			{
				MapRegion0001();
				MapRegion02BF();
				MapRegionC0CF();
				MapRegionD0FF();
			}
		}

		// ReSharper disable once UnusedMember.Global
		public void Initialize(
			Keyboard keyboard,
			IGamePort gamePort,
			ICassette cassette,
			ISpeaker speaker,
			IVideo video,
			ISlotClock noSlotClock,
			IPeripheralCard slot1,
			IPeripheralCard slot2,
			IPeripheralCard slot3,
			IPeripheralCard slot4,
			IPeripheralCard slot5,
			IDiskIIController slot6,
			IPeripheralCard slot7)
		{
			Keyboard = keyboard;
			_gamePort = gamePort;
			_cassette = cassette;
			Speaker = speaker;
			_video = video;
			_noSlotClock = noSlotClock;

			_slot1 = slot1;
			_slot2 = slot2;
			_slot3 = slot3;
			_slot4 = slot4;
			_slot5 = slot5;
			DiskIIController = slot6;
			_slot7 = slot7;

			// TODO: this is a lazy and more complicated way to do this
			_romInternalRegionC1CF = _appleIIe
				.Skip(0x100)
				.Take(_romInternalRegionC1CF.Length)
				.ToArray();

			_romRegionD0DF = _appleIIe
				.Skip(0x100 + _romInternalRegionC1CF.Length)
				.Take(_romRegionD0DF.Length)
				.ToArray();

			_romRegionE0FF = _appleIIe
				.Skip(0x100 + _romInternalRegionC1CF.Length + _romRegionD0DF.Length)
				.Take(_romRegionE0FF.Length)
				.ToArray();

			if (ReadRomRegionE0FF(0xFBB3) == 0x06 && ReadRomRegionE0FF(0xFBBF) == 0xC1)
			{
				Monitor = MonitorType.Standard;
			}
			else if (ReadRomRegionE0FF(0xFBB3) == 0x06
				&& ReadRomRegionE0FF(0xFBBF) == 0x00
				&& ReadRomRegionE0FF(0xFBC0) == 0xE0)
			{
				Monitor = MonitorType.Enhanced;
			}
		}

		public bool Lagged { get => _lagged; set => _lagged = value; }

		private IList<IPeripheralCard> Slots => new List<IPeripheralCard>
		{
			null,
			_slot1,
			_slot2,
			_slot3,
			_slot4,
			_slot5,
			DiskIIController,
			_slot7
		};

		public IDiskIIController DiskIIController { get; private set; }

		public Keyboard Keyboard { get; private set; }

		public ISpeaker Speaker { get; private set; }

		private void InitializeWriteDelegates()
		{
			WriteRamModeBankRegion = new Action<int, byte>[Video.ModeCount][][];
			for (int mode = 0; mode < Video.ModeCount; mode++)
			{
				WriteRamModeBankRegion[mode] = new[]
				{
					new Action<int, byte>[RegionCount], new Action<int, byte>[RegionCount]
				};
			}
			WriteRamModeBankRegion[Video.Mode0][BankMain][Region0407] = WriteRamMode0MainRegion0407;
			WriteRamModeBankRegion[Video.Mode0][BankMain][Region080B] = WriteRamMode0MainRegion080B;
			WriteRamModeBankRegion[Video.Mode1][BankMain][Region0407] = WriteRamMode1MainRegion0407;
			WriteRamModeBankRegion[Video.Mode1][BankMain][Region080B] = WriteRamMode1MainRegion080B;
			WriteRamModeBankRegion[Video.Mode2][BankMain][Region0407] = WriteRamMode2MainRegion0407;
			WriteRamModeBankRegion[Video.Mode2][BankMain][Region080B] = WriteRamMode2MainRegion080B;
			WriteRamModeBankRegion[Video.Mode2][BankAux][Region0407] = WriteRamMode2AuxRegion0407;
			WriteRamModeBankRegion[Video.Mode2][BankAux][Region080B] = WriteRamMode2AuxRegion080B;
			WriteRamModeBankRegion[Video.Mode3][BankMain][Region0407] = WriteRamMode3MainRegion0407;
			WriteRamModeBankRegion[Video.Mode3][BankMain][Region080B] = WriteRamMode3MainRegion080B;
			WriteRamModeBankRegion[Video.Mode4][BankMain][Region0407] = WriteRamMode4MainRegion0407;
			WriteRamModeBankRegion[Video.Mode4][BankMain][Region080B] = WriteRamMode4MainRegion080B;
			WriteRamModeBankRegion[Video.Mode4][BankAux][Region0407] = WriteRamMode4AuxRegion0407;
			WriteRamModeBankRegion[Video.Mode4][BankAux][Region080B] = WriteRamMode4AuxRegion080B;
			WriteRamModeBankRegion[Video.Mode5][BankMain][Region203F] = WriteRamMode5MainRegion203F;
			WriteRamModeBankRegion[Video.Mode5][BankMain][Region405F] = WriteRamMode5MainRegion405F;
			WriteRamModeBankRegion[Video.Mode6][BankMain][Region0407] = WriteRamMode6MainRegion0407;
			WriteRamModeBankRegion[Video.Mode6][BankMain][Region080B] = WriteRamMode6MainRegion080B;
			WriteRamModeBankRegion[Video.Mode6][BankMain][Region203F] = WriteRamMode6MainRegion203F;
			WriteRamModeBankRegion[Video.Mode6][BankMain][Region405F] = WriteRamMode6MainRegion405F;
			WriteRamModeBankRegion[Video.Mode7][BankMain][Region0407] = WriteRamMode7MainRegion0407;
			WriteRamModeBankRegion[Video.Mode7][BankMain][Region080B] = WriteRamMode7MainRegion080B;
			WriteRamModeBankRegion[Video.Mode7][BankMain][Region203F] = WriteRamMode7MainRegion203F;
			WriteRamModeBankRegion[Video.Mode7][BankMain][Region405F] = WriteRamMode7MainRegion405F;
			WriteRamModeBankRegion[Video.Mode7][BankAux][Region0407] = WriteRamMode7AuxRegion0407;
			WriteRamModeBankRegion[Video.Mode7][BankAux][Region080B] = WriteRamMode7AuxRegion080B;
			WriteRamModeBankRegion[Video.Mode8][BankMain][Region0407] = WriteRamMode8MainRegion0407;
			WriteRamModeBankRegion[Video.Mode8][BankMain][Region080B] = WriteRamMode8MainRegion080B;
			WriteRamModeBankRegion[Video.Mode9][BankMain][Region0407] = WriteRamMode9MainRegion0407;
			WriteRamModeBankRegion[Video.Mode9][BankMain][Region080B] = WriteRamMode9MainRegion080B;
			WriteRamModeBankRegion[Video.Mode9][BankAux][Region0407] = WriteRamMode9AuxRegion0407;
			WriteRamModeBankRegion[Video.Mode9][BankAux][Region080B] = WriteRamMode9AuxRegion080B;
			WriteRamModeBankRegion[Video.ModeA][BankMain][Region0407] = WriteRamModeAMainRegion0407;
			WriteRamModeBankRegion[Video.ModeA][BankMain][Region080B] = WriteRamModeAMainRegion080B;
			WriteRamModeBankRegion[Video.ModeB][BankMain][Region0407] = WriteRamModeBMainRegion0407;
			WriteRamModeBankRegion[Video.ModeB][BankMain][Region080B] = WriteRamModeBMainRegion080B;
			WriteRamModeBankRegion[Video.ModeB][BankAux][Region0407] = WriteRamModeBAuxRegion0407;
			WriteRamModeBankRegion[Video.ModeB][BankAux][Region080B] = WriteRamModeBAuxRegion080B;
			WriteRamModeBankRegion[Video.ModeC][BankMain][Region203F] = WriteRamModeCMainRegion203F;
			WriteRamModeBankRegion[Video.ModeC][BankMain][Region405F] = WriteRamModeCMainRegion405F;
			WriteRamModeBankRegion[Video.ModeD][BankMain][Region203F] = WriteRamModeDMainRegion203F;
			WriteRamModeBankRegion[Video.ModeD][BankMain][Region405F] = WriteRamModeDMainRegion405F;
			WriteRamModeBankRegion[Video.ModeD][BankAux][Region203F] = WriteRamModeDAuxRegion203F;
			WriteRamModeBankRegion[Video.ModeD][BankAux][Region405F] = WriteRamModeDAuxRegion405F;
			WriteRamModeBankRegion[Video.ModeE][BankMain][Region0407] = WriteRamModeEMainRegion0407;
			WriteRamModeBankRegion[Video.ModeE][BankMain][Region080B] = WriteRamModeEMainRegion080B;
			WriteRamModeBankRegion[Video.ModeE][BankMain][Region203F] = WriteRamModeEMainRegion203F;
			WriteRamModeBankRegion[Video.ModeE][BankMain][Region405F] = WriteRamModeEMainRegion405F;
			WriteRamModeBankRegion[Video.ModeF][BankMain][Region0407] = WriteRamModeFMainRegion0407;
			WriteRamModeBankRegion[Video.ModeF][BankMain][Region080B] = WriteRamModeFMainRegion080B;
			WriteRamModeBankRegion[Video.ModeF][BankMain][Region203F] = WriteRamModeFMainRegion203F;
			WriteRamModeBankRegion[Video.ModeF][BankMain][Region405F] = WriteRamModeFMainRegion405F;
			WriteRamModeBankRegion[Video.ModeF][BankAux][Region0407] = WriteRamModeFAuxRegion0407;
			WriteRamModeBankRegion[Video.ModeF][BankAux][Region080B] = WriteRamModeFAuxRegion080B;
			WriteRamModeBankRegion[Video.ModeF][BankAux][Region203F] = WriteRamModeFAuxRegion203F;
			WriteRamModeBankRegion[Video.ModeF][BankAux][Region405F] = WriteRamModeFAuxRegion405F;

			_writeIoRegionC0C0 = WriteIoRegionC0C0; // cache delegates; avoids garbage
			_writeIoRegionC1C7 = WriteIoRegionC1C7;
			_writeIoRegionC3C3 = WriteIoRegionC3C3;
			_writeIoRegionC8CF = WriteIoRegionC8CF;
			_writeRomRegionD0FF = WriteRomRegionD0FF;
		}

		// ReSharper disable once UnusedMember.Global
		public void Reset() // [7-3]
		{
			ResetState(State80Col | State80Store | StateAltChrSet | StateAltZP | StateBank1 | StateHRamRd | StateHRamPreWrt | StateHRamWrt | // HRamWrt' [5-23]
				StateHires | StatePage2 | StateRamRd | StateRamWrt | StateIntCXRom | StateSlotC3Rom | StateIntC8Rom | StateAn0 | StateAn1 | StateAn2 | StateAn3);
			SetState(StateDRes); // An3' -> DRes [8-20]

			MapRegion0001();
			MapRegion02BF();
			MapRegionC0CF();
			MapRegionD0FF();
		}

		public int ReadOpcode(int address)
		{
			int region = PageRegion[address >> 8];
			var result = ((address & 0xF000) != 0xC000) ? _regionRead[region][address - RegionBaseAddress[region]] : ReadIoRegionC0CF(address);
			ExecuteCallback?.Invoke((uint)address);
			ReadCallback?.Invoke((uint)address);
			return result;
		}

		public int Read(int address)
		{
			int region = PageRegion[address >> 8];
			var result = (address & 0xF000) != 0xC000
				? _regionRead[region][address - RegionBaseAddress[region]]
				: ReadIoRegionC0CF(address);
			ReadCallback?.Invoke((uint)address);
			return result;
		}

		public int Peek(int address)
		{
			int region = PageRegion[address >> 8];
			return (address & 0xF000) != 0xC000
				? _regionRead[region][address - RegionBaseAddress[region]]
				: ReadIoRegionC0CF(address);
		}

		public int ReadZeroPage(int address)
		{
			ReadCallback?.Invoke((uint)address);
			return _zeroPage[address];
		}

		public void Write(int address, int data)
		{
			int region = PageRegion[address >> 8];
			if (_writeRegion[region] == null)
			{
				WriteCallback?.Invoke((uint)address);
				_regionWrite[region][address - RegionBaseAddress[region]] = (byte)data;
			}
			else
			{
				WriteCallback?.Invoke((uint)address);
				_writeRegion[region](address, (byte)data);
			}
		}

		public void WriteZeroPage(int address, int data)
		{
			WriteCallback?.Invoke((uint)address);
			_zeroPage[address] = (byte)data;
		}

		public byte PeekMainRam(int address)
		{
			return address switch
			{
				>= 0 and < 0x0200 => _ramMainRegion0001[address - 0],
				>= 0x0200 and < 0xC000 => _ramMainRegion02BF[address - 0x0200],
				>= 0xC000 and < 0xD000 => _ramMainBank1RegionD0DF[address - 0xC000],
				>= 0xD000 and < 0xE000 => _ramMainBank2RegionD0DF[address - 0xD000],
				>= 0xE000 and < 0x10000 => _ramMainRegionE0FF[address - 0xE000],
				_ => throw new InvalidOperationException($"{nameof(address)} out of range ({address})")
			};
		}

		public void PokeMainRam(int address, byte value)
		{
			switch (address)
			{
				case >= 0 and < 0x0200:
					_ramMainRegion0001[address - 0] = value;
					break;
				case >= 0x0200 and < 0xC000:
					_ramMainRegion02BF[address - 0x0200] = value;
					break;
				case >= 0xC000 and < 0xD000:
					_ramMainBank1RegionD0DF[address - 0xC000] = value;
					break;
				case >= 0xD000 and < 0xE000:
					_ramMainBank2RegionD0DF[address - 0xD000] = value;
					break;
				case >= 0xE000 and < 0x10000:
					_ramMainRegionE0FF[address - 0xE000] = value;
					break;
				default:
					throw new InvalidOperationException($"{nameof(address)} out of range ({address})");
			}
		}

		public byte PeekAuxRam(int address)
		{
			return address switch
			{
				>= 0 and < 0x0200 => _ramAuxRegion0001[address - 0],
				>= 0x0200 and < 0xC000 => _ramAuxRegion02BF[address - 0x0200],
				>= 0xC000 and < 0xD000 => _ramAuxBank1RegionD0DF[address - 0xC000],
				>= 0xD000 and < 0xE000 => _ramAuxBank2RegionD0DF[address - 0xD000],
				>= 0xE000 and < 0x10000 => _ramAuxRegionE0FF[address - 0xE000],
				_ => throw new InvalidOperationException($"{nameof(address)} out of range ({address})")
			};
		}

		public void PokeAuxRam(int address, byte value)
		{
			switch (address)
			{
				case >= 0 and < 0x0200:
					_ramAuxRegion0001[address - 0] = value;
					break;
				case >= 0x0200 and < 0xC000:
					_ramAuxRegion02BF[address - 0x0200] = value;
					break;
				case >= 0xC000 and < 0xD000:
					_ramAuxBank1RegionD0DF[address - 0xC000] = value;
					break;
				case >= 0xD000 and < 0xE000:
					_ramAuxBank2RegionD0DF[address - 0xD000] = value;
					break;
				case >= 0xE000 and < 0x10000:
					_ramAuxRegionE0FF[address - 0xE000] = value;
					break;
				default:
					throw new InvalidOperationException($"{nameof(address)} out of range ({address})");
			}
		}

		private int ReadIoRegionC0CF(int address)
		{
			switch (address & 0xFF00)
			{
				case 0xC000:
					return ReadIoRegionC0C0(address);

				case 0xC100:
				case 0xC200:
				case 0xC400:
				case 0xC500:
				case 0xC600:
				case 0xC700:
					return ReadIoRegionC1C7(address);

				case 0xC300:
					return ReadIoRegionC3C3(address);

				case 0xC800:
				case 0xC900:
				case 0xCA00:
				case 0xCB00:
				case 0xCC00:
				case 0xCD00:
				case 0xCE00:
				case 0xCF00:
					return ReadIoRegionC8CF(address);
			}

			return _video.ReadFloatingBus();
		}

		private int ReadIoRegionC0C0(int address)
		{
			if (0xC000 <= address && address <= 0xC00F || 0xC061 <= address && address <= 0xC067 || 0xC069 <= address && address <= 0xC06F)
			{
				Lagged = false;
				InputCallback?.Invoke();
			}

			switch (address)
			{
				case 0xC000:
				case 0xC001:
				case 0xC002:
				case 0xC003:
				case 0xC004:
				case 0xC005:
				case 0xC006:
				case 0xC007: // [7-15]
				case 0xC008:
				case 0xC009:
				case 0xC00A:
				case 0xC00B:
				case 0xC00C:
				case 0xC00D:
				case 0xC00E:
				case 0xC00F:
					return SetBit7(Keyboard.Latch, Keyboard.Strobe);

				case 0xC010:
					Keyboard.ResetStrobe();
					return SetBit7(Keyboard.Latch, Keyboard.IsAnyKeyDown);

				case 0xC011:
					return SetBit7(Keyboard.Latch, !IsHighRamBank1); // Bank1' [5-22]

				case 0xC012:
					return SetBit7(Keyboard.Latch, IsHighRamRead);

				case 0xC013:
					return SetBit7(Keyboard.Latch, IsRamReadAux);

				case 0xC014:
					return SetBit7(Keyboard.Latch, IsRamWriteAux);

				case 0xC015:
					return SetBit7(Keyboard.Latch, IsRomC1CFInternal);

				case 0xC016:
					return SetBit7(Keyboard.Latch, IsZeroPageAux);

				case 0xC017:
					return SetBit7(Keyboard.Latch, IsRomC3C3External);

				case 0xC018:
					return SetBit7(Keyboard.Latch, Is80Store);

				case 0xC019:
					return SetBit7(Keyboard.Latch, !_video.IsVBlank); // Vbl' [7-5]

				case 0xC01A:
					return SetBit7(Keyboard.Latch, IsText);

				case 0xC01B:
					return SetBit7(Keyboard.Latch, IsMixed);

				case 0xC01C:
					return SetBit7(Keyboard.Latch, IsPage2);

				case 0xC01D:
					return SetBit7(Keyboard.Latch, IsHires);

				case 0xC01E:
					return SetBit7(Keyboard.Latch, IsCharSetAlternate);

				case 0xC01F:
					return SetBit7(Keyboard.Latch, Is80Columns);

				case 0xC020:
				case 0xC021:
				case 0xC022:
				case 0xC023:
				case 0xC024:
				case 0xC025:
				case 0xC026:
				case 0xC027: // [7-8]
				case 0xC028:
				case 0xC029:
				case 0xC02A:
				case 0xC02B:
				case 0xC02C:
				case 0xC02D:
				case 0xC02E:
				case 0xC02F:
					_cassette.ToggleOutput();
					break;

				case 0xC030:
				case 0xC031:
				case 0xC032:
				case 0xC033:
				case 0xC034:
				case 0xC035:
				case 0xC036:
				case 0xC037: // [7-9]
				case 0xC038:
				case 0xC039:
				case 0xC03A:
				case 0xC03B:
				case 0xC03C:
				case 0xC03D:
				case 0xC03E:
				case 0xC03F:
					Speaker.ToggleOutput();
					break;

				case 0xC040:
				case 0xC041:
				case 0xC042:
				case 0xC043:
				case 0xC044:
				case 0xC045:
				case 0xC046:
				case 0xC047: // [2-18]
				case 0xC048:
				case 0xC049:
				case 0xC04A:
				case 0xC04B:
				case 0xC04C:
				case 0xC04D:
				case 0xC04E:
				case 0xC04F:
					break;

				case 0xC050:
				case 0xC051:
					SetText(TestBit(address, 0));
					break;

				case 0xC052:
				case 0xC053:
					SetMixed(TestBit(address, 0));
					break;

				case 0xC054:
				case 0xC055:
					SetPage2(TestBit(address, 0));
					break;

				case 0xC056:
				case 0xC057:
					SetHires(TestBit(address, 0));
					break;

				case 0xC058:
				case 0xC059:
					SetAnnunciator0(TestBit(address, 0));
					break;

				case 0xC05A:
				case 0xC05B:
					SetAnnunciator1(TestBit(address, 0));
					break;

				case 0xC05C:
				case 0xC05D:
					SetAnnunciator2(TestBit(address, 0));
					break;

				case 0xC05E:
				case 0xC05F:
					SetAnnunciator3(TestBit(address, 0));
					SetDoubleRes(!TestBit(address, 0));
					break;

				case 0xC060:
				case 0xC068: // [2-18, 7-5]
					return SetBit7(_video.ReadFloatingBus(), _cassette.ReadInput()); // [7-8]

				case 0xC061:
				case 0xC069:
					return SetBit7(_video.ReadFloatingBus(), _gamePort.ReadButton0());

				case 0xC062:
				case 0xC06A:
					return SetBit7(_video.ReadFloatingBus(), _gamePort.ReadButton1());

				case 0xC063:
				case 0xC06B:
					return SetBit7(_video.ReadFloatingBus(), _gamePort.ReadButton2());

				case 0xC064:
				case 0xC06C:
					return SetBit7(_video.ReadFloatingBus(), _gamePort.Paddle0Strobe);

				case 0xC065:
				case 0xC06D:
					return SetBit7(_video.ReadFloatingBus(), _gamePort.Paddle1Strobe);

				case 0xC066:
				case 0xC06E:
					return SetBit7(_video.ReadFloatingBus(), _gamePort.Paddle2Strobe);

				case 0xC067:
				case 0xC06F:
					return SetBit7(_video.ReadFloatingBus(), _gamePort.Paddle3Strobe);

				case 0xC070:
				case 0xC071:
				case 0xC072:
				case 0xC073:
				case 0xC074:
				case 0xC075:
				case 0xC076:
				case 0xC077:
				case 0xC078:
				case 0xC079:
				case 0xC07A:
				case 0xC07B:
				case 0xC07C:
				case 0xC07D:
				case 0xC07E:
				case 0xC07F:
					_gamePort.TriggerTimers();
					break;

				case 0xC080:
				case 0xC081:
				case 0xC082:
				case 0xC083:
				case 0xC084:
				case 0xC085:
				case 0xC086:
				case 0xC087: // slot0 [5-23]
				case 0xC088:
				case 0xC089:
				case 0xC08A:
				case 0xC08B:
				case 0xC08C:
				case 0xC08D:
				case 0xC08E:
				case 0xC08F:
					SetHighRam(address, true);
					break;

				case 0xC090:
				case 0xC091:
				case 0xC092:
				case 0xC093:
				case 0xC094:
				case 0xC095:
				case 0xC096:
				case 0xC097: // slot1
				case 0xC098:
				case 0xC099:
				case 0xC09A:
				case 0xC09B:
				case 0xC09C:
				case 0xC09D:
				case 0xC09E:
				case 0xC09F:
					return _slot1.ReadIoRegionC0C0(address);

				case 0xC0A0:
				case 0xC0A1:
				case 0xC0A2:
				case 0xC0A3:
				case 0xC0A4:
				case 0xC0A5:
				case 0xC0A6:
				case 0xC0A7: // slot2
				case 0xC0A8:
				case 0xC0A9:
				case 0xC0AA:
				case 0xC0AB:
				case 0xC0AC:
				case 0xC0AD:
				case 0xC0AE:
				case 0xC0AF:
					return _slot2.ReadIoRegionC0C0(address);

				case 0xC0B0:
				case 0xC0B1:
				case 0xC0B2:
				case 0xC0B3:
				case 0xC0B4:
				case 0xC0B5:
				case 0xC0B6:
				case 0xC0B7: // slot3
				case 0xC0B8:
				case 0xC0B9:
				case 0xC0BA:
				case 0xC0BB:
				case 0xC0BC:
				case 0xC0BD:
				case 0xC0BE:
				case 0xC0BF:
					return _slot3.ReadIoRegionC0C0(address);

				case 0xC0C0:
				case 0xC0C1:
				case 0xC0C2:
				case 0xC0C3:
				case 0xC0C4:
				case 0xC0C5:
				case 0xC0C6:
				case 0xC0C7: // slot4
				case 0xC0C8:
				case 0xC0C9:
				case 0xC0CA:
				case 0xC0CB:
				case 0xC0CC:
				case 0xC0CD:
				case 0xC0CE:
				case 0xC0CF:
					return _slot4.ReadIoRegionC0C0(address);

				case 0xC0D0:
				case 0xC0D1:
				case 0xC0D2:
				case 0xC0D3:
				case 0xC0D4:
				case 0xC0D5:
				case 0xC0D6:
				case 0xC0D7: // slot5
				case 0xC0D8:
				case 0xC0D9:
				case 0xC0DA:
				case 0xC0DB:
				case 0xC0DC:
				case 0xC0DD:
				case 0xC0DE:
				case 0xC0DF:
					return _slot5.ReadIoRegionC0C0(address);

				case 0xC0E0:
				case 0xC0E1:
				case 0xC0E2:
				case 0xC0E3:
				case 0xC0E4:
				case 0xC0E5:
				case 0xC0E6:
				case 0xC0E7: // slot6
				case 0xC0E8:
				case 0xC0E9:
				case 0xC0EA:
				case 0xC0EB:
				case 0xC0EC:
				case 0xC0ED:
				case 0xC0EE:
				case 0xC0EF:
					return DiskIIController.ReadIoRegionC0C0(address);

				case 0xC0F0:
				case 0xC0F1:
				case 0xC0F2:
				case 0xC0F3:
				case 0xC0F4:
				case 0xC0F5:
				case 0xC0F6:
				case 0xC0F7: // slot7
				case 0xC0F8:
				case 0xC0F9:
				case 0xC0FA:
				case 0xC0FB:
				case 0xC0FC:
				case 0xC0FD:
				case 0xC0FE:
				case 0xC0FF:
					return _slot7.ReadIoRegionC0C0(address);

				default:
					throw new ArgumentOutOfRangeException(nameof(address));
			}

			return _video.ReadFloatingBus();
		}

		private int ReadIoRegionC1C7(int address)
		{
			_slotRegionC8CF = (address >> 8) & 0x07;
			return IsRomC1CFInternal ? _romInternalRegionC1CF[address - 0xC100] : Slots[_slotRegionC8CF].ReadIoRegionC1C7(address);
		}

		private int ReadIoRegionC3C3(int address)
		{
			_slotRegionC8CF = 3;
			if (!IsRomC3C3External)
			{
				SetRomC8CF(true); // $C3XX sets IntC8Rom; inhibits I/O Strobe' [5-28, 7-21]
			}

			return IsRomC1CFInternal || !IsRomC3C3External
				? _noSlotClock.Read(address, _romInternalRegionC1CF[address - 0xC100])
				: _slot3.ReadIoRegionC1C7(address);
		}

		private int ReadIoRegionC8CF(int address)
		{
			if (address == 0xCFFF)
			{
				SetRomC8CF(false); // $CFFF resets IntC8Rom [5-28, 7-21]
			}
			return IsRomC1CFInternal || IsRomC8CFInternal
				? _noSlotClock.Read(address, _romInternalRegionC1CF[address - 0xC100])
				: Slots[_slotRegionC8CF].ReadIoRegionC8CF(address);
		}

		public int ReadRamMainRegion02BF(int address)
		{
			return _ramMainRegion02BF[address - 0x0200];
		}

		public int ReadRamAuxRegion02BF(int address)
		{
			return _ramAuxRegion02BF[address - 0x0200];
		}

		public int ReadRomRegionE0FF(int address)
		{
			return _romRegionE0FF[address - 0xE000];
		}

		private void WriteIoRegionC0C0(int address, byte data)
		{
			switch (address)
			{
				case 0xC000:
				case 0xC001: // [5-22]
					Set80Store(TestBit(address, 0));
					break;

				case 0xC002:
				case 0xC003:
					SetRamRead(TestBit(address, 0));
					break;

				case 0xC004:
				case 0xC005:
					SetRamWrite(TestBit(address, 0));
					break;

				case 0xC006:
				case 0xC007:
					SetRomC1CF(TestBit(address, 0));
					break;

				case 0xC008:
				case 0xC009:
					SetZeroPage(TestBit(address, 0));
					break;

				case 0xC00A:
				case 0xC00B:
					SetRomC3C3(TestBit(address, 0));
					break;

				case 0xC00C:
				case 0xC00D: // [7-5]
					Set80Columns(TestBit(address, 0));
					break;

				case 0xC00E:
				case 0xC00F:
					SetCharSet(TestBit(address, 0));
					break;

				case 0xC010:
				case 0xC011:
				case 0xC012:
				case 0xC013:
				case 0xC014:
				case 0xC015:
				case 0xC016:
				case 0xC017: // [7-15]
				case 0xC018:
				case 0xC019:
				case 0xC01A:
				case 0xC01B:
				case 0xC01C:
				case 0xC01D:
				case 0xC01E:
				case 0xC01F:
					Keyboard.ResetStrobe();
					break;

				case 0xC020:
				case 0xC021:
				case 0xC022:
				case 0xC023:
				case 0xC024:
				case 0xC025:
				case 0xC026:
				case 0xC027: // [7-8]
				case 0xC028:
				case 0xC029:
				case 0xC02A:
				case 0xC02B:
				case 0xC02C:
				case 0xC02D:
				case 0xC02E:
				case 0xC02F:
					_cassette.ToggleOutput();
					break;

				case 0xC030:
				case 0xC031:
				case 0xC032:
				case 0xC033:
				case 0xC034:
				case 0xC035:
				case 0xC036:
				case 0xC037: // [7-9]
				case 0xC038:
				case 0xC039:
				case 0xC03A:
				case 0xC03B:
				case 0xC03C:
				case 0xC03D:
				case 0xC03E:
				case 0xC03F:
					Speaker.ToggleOutput();
					break;

				case 0xC040:
				case 0xC041:
				case 0xC042:
				case 0xC043:
				case 0xC044:
				case 0xC045:
				case 0xC046:
				case 0xC047: // [2-18]
				case 0xC048:
				case 0xC049:
				case 0xC04A:
				case 0xC04B:
				case 0xC04C:
				case 0xC04D:
				case 0xC04E:
				case 0xC04F:
					break;

				case 0xC050:
				case 0xC051:
					SetText(TestBit(address, 0));
					break;

				case 0xC052:
				case 0xC053:
					SetMixed(TestBit(address, 0));
					break;

				case 0xC054:
				case 0xC055:
					SetPage2(TestBit(address, 0));
					break;

				case 0xC056:
				case 0xC057:
					SetHires(TestBit(address, 0));
					break;

				case 0xC058:
				case 0xC059:
					SetAnnunciator0(TestBit(address, 0));
					break;

				case 0xC05A:
				case 0xC05B:
					SetAnnunciator1(TestBit(address, 0));
					break;

				case 0xC05C:
				case 0xC05D:
					SetAnnunciator2(TestBit(address, 0));
					break;

				case 0xC05E:
				case 0xC05F:
					SetAnnunciator3(TestBit(address, 0));
					SetDoubleRes(!TestBit(address, 0));
					break;

				case 0xC060:
				case 0xC061:
				case 0xC062:
				case 0xC063:
				case 0xC064:
				case 0xC065:
				case 0xC066:
				case 0xC067: // [2-18, 7-5]
				case 0xC068:
				case 0xC069:
				case 0xC06A:
				case 0xC06B:
				case 0xC06C:
				case 0xC06D:
				case 0xC06E:
				case 0xC06F:
					break;

				case 0xC070:
				case 0xC071:
				case 0xC072:
				case 0xC073:
				case 0xC074:
				case 0xC075:
				case 0xC076:
				case 0xC077:
				case 0xC078:
				case 0xC079:
				case 0xC07A:
				case 0xC07B:
				case 0xC07C:
				case 0xC07D:
				case 0xC07E:
				case 0xC07F:
					_gamePort.TriggerTimers();
					break;

				case 0xC080:
				case 0xC081:
				case 0xC082:
				case 0xC083:
				case 0xC084:
				case 0xC085:
				case 0xC086:
				case 0xC087: // slot0 [5-23]
				case 0xC088:
				case 0xC089:
				case 0xC08A:
				case 0xC08B:
				case 0xC08C:
				case 0xC08D:
				case 0xC08E:
				case 0xC08F:
					SetHighRam(address, false);
					break;

				case 0xC090:
				case 0xC091:
				case 0xC092:
				case 0xC093:
				case 0xC094:
				case 0xC095:
				case 0xC096:
				case 0xC097: // slot1
				case 0xC098:
				case 0xC099:
				case 0xC09A:
				case 0xC09B:
				case 0xC09C:
				case 0xC09D:
				case 0xC09E:
				case 0xC09F:
					_slot1.WriteIoRegionC0C0(address, data);
					break;

				case 0xC0A0:
				case 0xC0A1:
				case 0xC0A2:
				case 0xC0A3:
				case 0xC0A4:
				case 0xC0A5:
				case 0xC0A6:
				case 0xC0A7: // slot2
				case 0xC0A8:
				case 0xC0A9:
				case 0xC0AA:
				case 0xC0AB:
				case 0xC0AC:
				case 0xC0AD:
				case 0xC0AE:
				case 0xC0AF:
					_slot2.WriteIoRegionC0C0(address, data);
					break;

				case 0xC0B0:
				case 0xC0B1:
				case 0xC0B2:
				case 0xC0B3:
				case 0xC0B4:
				case 0xC0B5:
				case 0xC0B6:
				case 0xC0B7: // slot3
				case 0xC0B8:
				case 0xC0B9:
				case 0xC0BA:
				case 0xC0BB:
				case 0xC0BC:
				case 0xC0BD:
				case 0xC0BE:
				case 0xC0BF:
					_slot3.WriteIoRegionC0C0(address, data);
					break;

				case 0xC0C0:
				case 0xC0C1:
				case 0xC0C2:
				case 0xC0C3:
				case 0xC0C4:
				case 0xC0C5:
				case 0xC0C6:
				case 0xC0C7: // slot4
				case 0xC0C8:
				case 0xC0C9:
				case 0xC0CA:
				case 0xC0CB:
				case 0xC0CC:
				case 0xC0CD:
				case 0xC0CE:
				case 0xC0CF:
					_slot4.WriteIoRegionC0C0(address, data);
					break;

				case 0xC0D0:
				case 0xC0D1:
				case 0xC0D2:
				case 0xC0D3:
				case 0xC0D4:
				case 0xC0D5:
				case 0xC0D6:
				case 0xC0D7: // slot5
				case 0xC0D8:
				case 0xC0D9:
				case 0xC0DA:
				case 0xC0DB:
				case 0xC0DC:
				case 0xC0DD:
				case 0xC0DE:
				case 0xC0DF:
					_slot5.WriteIoRegionC0C0(address, data);
					break;

				case 0xC0E0:
				case 0xC0E1:
				case 0xC0E2:
				case 0xC0E3:
				case 0xC0E4:
				case 0xC0E5:
				case 0xC0E6:
				case 0xC0E7: // slot6
				case 0xC0E8:
				case 0xC0E9:
				case 0xC0EA:
				case 0xC0EB:
				case 0xC0EC:
				case 0xC0ED:
				case 0xC0EE:
				case 0xC0EF:
					DiskIIController.WriteIoRegionC0C0(address, data);
					break;

				case 0xC0F0:
				case 0xC0F1:
				case 0xC0F2:
				case 0xC0F3:
				case 0xC0F4:
				case 0xC0F5:
				case 0xC0F6:
				case 0xC0F7: // slot7
				case 0xC0F8:
				case 0xC0F9:
				case 0xC0FA:
				case 0xC0FB:
				case 0xC0FC:
				case 0xC0FD:
				case 0xC0FE:
				case 0xC0FF:
					_slot7.WriteIoRegionC0C0(address, data);
					break;

				default:
					throw new ArgumentOutOfRangeException(nameof(address));
			}
		}

		private void WriteIoRegionC1C7(int address, byte data)
		{
			_slotRegionC8CF = (address >> 8) & 0x07;
			if (!IsRomC1CFInternal)
			{
				Slots[_slotRegionC8CF].WriteIoRegionC1C7(address, data);
			}
		}

		private void WriteIoRegionC3C3(int address, byte data)
		{
			_slotRegionC8CF = 3;
			if (!IsRomC3C3External)
			{
				SetRomC8CF(true); // $C3XX sets IntC8Rom; inhibits I/O Strobe' [5-28, 7-21]
			}
			if (IsRomC1CFInternal || !IsRomC3C3External)
			{
				_noSlotClock.Write(address);
			}
			else
			{
				_slot3.WriteIoRegionC1C7(address, data);
			}
		}

		private void WriteIoRegionC8CF(int address, byte data)
		{
			if (address == 0xCFFF)
			{
				SetRomC8CF(false); // $CFFF resets IntC8Rom [5-28, 7-21]
			}
			if (IsRomC1CFInternal || IsRomC8CFInternal)
			{
				_noSlotClock.Write(address);
			}
			else
			{
				Slots[_slotRegionC8CF].WriteIoRegionC8CF(address, data);
			}
		}

		private void WriteRamMode0MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // lores page1
			}
		}

		private void WriteRamMode0MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // lores page2
			}
		}

		private void WriteRamMode1MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // text40 page1
			}
		}

		private void WriteRamMode1MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // text40 page2
			}
		}

		private void WriteRamMode2MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // text80 page1
			}
		}

		private void WriteRamMode2MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // text80 page2
			}
		}

		private void WriteRamMode2AuxRegion0407(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // text80 page1
			}
		}

		private void WriteRamMode2AuxRegion080B(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // text80 page2
			}
		}

		private void WriteRamMode3MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // lores & text40 page1
			}
		}

		private void WriteRamMode3MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // lores & text40 page2
			}
		}

		private void WriteRamMode4MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // lores & text80 page1
			}
		}

		private void WriteRamMode4MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // lores & text80 page2
			}
		}

		private void WriteRamMode4AuxRegion0407(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0400); // [lores &] text80 page1
			}
		}

		private void WriteRamMode4AuxRegion080B(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0800); // [lores &] text80 page2
			}
		}

		private void WriteRamMode5MainRegion203F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x2000); // hires page1
			}
		}

		private void WriteRamMode5MainRegion405F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x4000); // hires page2
			}
		}

		private void WriteRamMode6MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0400); // [hires &] text40 page1
			}
		}

		private void WriteRamMode6MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0800); // [hires &] text40 page2
			}
		}

		private void WriteRamMode6MainRegion203F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x2000); // hires [& text40] page1
			}
		}

		private void WriteRamMode6MainRegion405F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x4000); // hires [& text40] page2
			}
		}

		private void WriteRamMode7MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0400); // [hires &] text80 page1
			}
		}

		private void WriteRamMode7MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0800); // [hires &] text80 page2
			}
		}

		private void WriteRamMode7MainRegion203F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x2000); // hires [& text80] page1
			}
		}

		private void WriteRamMode7MainRegion405F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x4000); // hires [& text80] page2
			}
		}

		private void WriteRamMode7AuxRegion0407(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0400); // [hires &] text80 page1
			}
		}

		private void WriteRamMode7AuxRegion080B(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0800); // [hires &] text80 page2
			}
		}

		private void WriteRamMode8MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // 7mlores page1
			}
		}

		private void WriteRamMode8MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // 7mlores page2
			}
		}

		private void WriteRamMode9MainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // dlores page1
			}
		}

		private void WriteRamMode9MainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // dlores page2
			}
		}

		private void WriteRamMode9AuxRegion0407(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // dlores page1
			}
		}

		private void WriteRamMode9AuxRegion080B(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // dlores page2
			}
		}

		private void WriteRamModeAMainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // 7mlores & text40 page1
			}
		}

		private void WriteRamModeAMainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // 7mlores & text40 page2
			}
		}

		private void WriteRamModeBMainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // dlores & text80 page1
			}
		}

		private void WriteRamModeBMainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // dlores & text80 page2
			}
		}

		private void WriteRamModeBAuxRegion0407(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0400); // dlores & text80 page1
			}
		}

		private void WriteRamModeBAuxRegion080B(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x0800); // dlores & text80 page2
			}
		}

		private void WriteRamModeCMainRegion203F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x2000); // ndhires page1
			}
		}

		private void WriteRamModeCMainRegion405F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x4000); // ndhires page2
			}
		}

		private void WriteRamModeDMainRegion203F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x2000); // dhires page1
			}
		}

		private void WriteRamModeDMainRegion405F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x4000); // dhires page2
			}
		}

		private void WriteRamModeDAuxRegion203F(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x2000); // dhires page1
			}
		}

		private void WriteRamModeDAuxRegion405F(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCell(address - 0x4000); // dhires page2
			}
		}

		private void WriteRamModeEMainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0400); // [ndhires &] text40 page1
			}
		}

		private void WriteRamModeEMainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0800); // [ndhires &] text40 page2
			}
		}

		private void WriteRamModeEMainRegion203F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x2000); // ndhires [& text40] page1
			}
		}

		private void WriteRamModeEMainRegion405F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x4000); // ndhires [& text40] page2
			}
		}

		private void WriteRamModeFMainRegion0407(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0400); // [dhires &] text80 page1
			}
		}

		private void WriteRamModeFMainRegion080B(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0800); // [dhires &] text80 page2
			}
		}

		private void WriteRamModeFMainRegion203F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x2000); // dhires [& text80] page1
			}
		}

		private void WriteRamModeFMainRegion405F(int address, byte data)
		{
			if (_ramMainRegion02BF[address - 0x0200] != data)
			{
				_ramMainRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x4000); // dhires [& text80] page2
			}
		}

		private void WriteRamModeFAuxRegion0407(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0400); // [dhires &] text80 page1
			}
		}

		private void WriteRamModeFAuxRegion080B(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixedText(address - 0x0800); // [dhires &] text80 page2
			}
		}

		private void WriteRamModeFAuxRegion203F(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x2000); // dhires [& text80] page1
			}
		}

		private void WriteRamModeFAuxRegion405F(int address, byte data)
		{
			if (_ramAuxRegion02BF[address - 0x0200] != data)
			{
				_ramAuxRegion02BF[address - 0x0200] = data;
				_video.DirtyCellMixed(address - 0x4000); // dhires [& text80] page2
			}
		}

		private void WriteRomRegionD0FF(int address, byte data)
		{
		}

		private void MapRegion0001()
		{
			if (!IsZeroPageAux)
			{
				_regionRead[Region0001] = _ramMainRegion0001;
				_regionWrite[Region0001] = _ramMainRegion0001;
				_zeroPage = _ramMainRegion0001;
			}
			else
			{
				_regionRead[Region0001] = _ramAuxRegion0001;
				_regionWrite[Region0001] = _ramAuxRegion0001;
				_zeroPage = _ramAuxRegion0001;
			}
			_writeRegion[Region0001] = null;
		}

		private void MapRegion02BF()
		{
			if (!IsRamReadAux)
			{
				_regionRead[Region02BF] = _ramMainRegion02BF;
				_regionRead[Region080B] = _ramMainRegion02BF;
				_regionRead[Region405F] = _ramMainRegion02BF;
			}
			else
			{
				_regionRead[Region02BF] = _ramAuxRegion02BF;
				_regionRead[Region080B] = _ramAuxRegion02BF;
				_regionRead[Region405F] = _ramAuxRegion02BF;
			}
			int mode = VideoMode;
			if (!IsRamWriteAux)
			{
				_regionWrite[Region02BF] = _ramMainRegion02BF;
				_regionWrite[Region080B] = _ramMainRegion02BF;
				_regionWrite[Region405F] = _ramMainRegion02BF;
				_writeRegion[Region02BF] = null;
				_writeRegion[Region080B] = WriteRamModeBankRegion[mode][BankMain][Region080B];
				_writeRegion[Region405F] = WriteRamModeBankRegion[mode][BankMain][Region405F];
			}
			else
			{
				_regionWrite[Region02BF] = _ramAuxRegion02BF;
				_regionWrite[Region080B] = _ramAuxRegion02BF;
				_regionWrite[Region405F] = _ramAuxRegion02BF;
				_writeRegion[Region02BF] = null;
				_writeRegion[Region080B] = WriteRamModeBankRegion[mode][BankAux][Region080B];
				_writeRegion[Region405F] = WriteRamModeBankRegion[mode][BankAux][Region405F];
			}
			MapRegion0407();
			MapRegion203F();
		}

		private void MapRegion0407()
		{
			if (!IsRamReadAuxRegion0407)
			{
				_regionRead[Region0407] = _ramMainRegion02BF;
			}
			else
			{
				_regionRead[Region0407] = _ramAuxRegion02BF;
			}
			int mode = VideoMode;
			if (!IsRamWriteAuxRegion0407)
			{
				_regionWrite[Region0407] = _ramMainRegion02BF;
				_writeRegion[Region0407] = WriteRamModeBankRegion[mode][BankMain][Region0407];
			}
			else
			{
				_regionWrite[Region0407] = _ramAuxRegion02BF;
				_writeRegion[Region0407] = WriteRamModeBankRegion[mode][BankAux][Region0407];
			}
		}

		private void MapRegion203F()
		{
			if (!IsRamReadAuxRegion203F)
			{
				_regionRead[Region203F] = _ramMainRegion02BF;
			}
			else
			{
				_regionRead[Region203F] = _ramAuxRegion02BF;
			}
			int mode = VideoMode;
			if (!IsRamWriteAuxRegion203F)
			{
				_regionWrite[Region203F] = _ramMainRegion02BF;
				_writeRegion[Region203F] = WriteRamModeBankRegion[mode][BankMain][Region203F];
			}
			else
			{
				_regionWrite[Region203F] = _ramAuxRegion02BF;
				_writeRegion[Region203F] = WriteRamModeBankRegion[mode][BankAux][Region203F];
			}
		}

		private void MapRegionC0CF()
		{
			_regionRead[RegionC0C0] = null;
			if (IsRomC1CFInternal)
			{
				_regionRead[RegionC1C7] = _romInternalRegionC1CF;
				_regionRead[RegionC3C3] = _romInternalRegionC1CF;
				_regionRead[RegionC8CF] = _romInternalRegionC1CF;
			}
			else
			{
				_regionRead[RegionC1C7] = _romExternalRegionC1CF;
				_regionRead[RegionC3C3] = IsRomC3C3External ? _romExternalRegionC1CF : _romInternalRegionC1CF;
				_regionRead[RegionC8CF] = !IsRomC8CFInternal ? _romExternalRegionC1CF : _romInternalRegionC1CF;
			}
			_regionWrite[RegionC0C0] = null;
			_regionWrite[RegionC1C7] = null;
			_regionWrite[RegionC3C3] = null;
			_regionWrite[RegionC8CF] = null;
			_writeRegion[RegionC0C0] = _writeIoRegionC0C0;
			_writeRegion[RegionC1C7] = _writeIoRegionC1C7;
			_writeRegion[RegionC3C3] = _writeIoRegionC3C3;
			_writeRegion[RegionC8CF] = _writeIoRegionC8CF;
		}

		private void MapRegionD0FF()
		{
			if (IsHighRamRead)
			{
				if (!IsHighRamAux)
				{
					_regionRead[RegionD0DF] = IsHighRamBank1 ? _ramMainBank1RegionD0DF : _ramMainBank2RegionD0DF;
					_regionRead[RegionE0FF] = _ramMainRegionE0FF;
				}
				else
				{
					_regionRead[RegionD0DF] = IsHighRamBank1 ? _ramAuxBank1RegionD0DF : _ramAuxBank2RegionD0DF;
					_regionRead[RegionE0FF] = _ramAuxRegionE0FF;
				}
			}
			else
			{
				_regionRead[RegionD0DF] = _romRegionD0DF;
				_regionRead[RegionE0FF] = _romRegionE0FF;
			}
			if (IsHighRamWrite)
			{
				if (!IsHighRamAux)
				{
					_regionWrite[RegionD0DF] = IsHighRamBank1 ? _ramMainBank1RegionD0DF : _ramMainBank2RegionD0DF;
					_regionWrite[RegionE0FF] = _ramMainRegionE0FF;
				}
				else
				{
					_regionWrite[RegionD0DF] = IsHighRamBank1 ? _ramAuxBank1RegionD0DF : _ramAuxBank2RegionD0DF;
					_regionWrite[RegionE0FF] = _ramAuxRegionE0FF;
				}
				_writeRegion[RegionD0DF] = null;
				_writeRegion[RegionE0FF] = null;
			}
			else
			{
				_regionWrite[RegionD0DF] = null;
				_regionWrite[RegionE0FF] = null;
				_writeRegion[RegionD0DF] = _writeRomRegionD0FF;
				_writeRegion[RegionE0FF] = _writeRomRegionD0FF;
			}
		}

		private void Set80Columns(bool value)
		{
			if (!TestState(State80Col, value))
			{
				SetState(State80Col, value);
				MapRegion02BF();
				_video.DirtyScreen();
			}
		}

		private void Set80Store(bool value)
		{
			if (!TestState(State80Store, value))
			{
				SetState(State80Store, value);
				if (IsPage2) // [5-7, 8-19]
				{
					MapRegion02BF();
					_video.DirtyScreen();
				}
				else
				{
					MapRegion0407();
					MapRegion203F();
				}
			}
		}

		private void SetAnnunciator0(bool value)
		{
			SetState(StateAn0, value);
		}

		private void SetAnnunciator1(bool value)
		{
			SetState(StateAn1, value);
		}

		private void SetAnnunciator2(bool value)
		{
			SetState(StateAn2, value);
		}

		private void SetAnnunciator3(bool value)
		{
			SetState(StateAn3, value);
		}

		private void SetCharSet(bool value)
		{
			if (!TestState(StateAltChrSet, value))
			{
				SetState(StateAltChrSet, value);
				_video.SetCharSet();
			}
		}

		private void SetDoubleRes(bool value)
		{
			if (!TestState(StateDRes, value))
			{
				SetState(StateDRes, value);
				MapRegion02BF();
				_video.DirtyScreen();
			}
		}

		private void SetHighRam(int address, bool isRead)
		{
			SetState(StateBank1, TestBit(address, 3)); // A3 [5-22]
			SetState(StateHRamRd, TestMask(address, 0x3, 0x3) || TestMask(address, 0x3, 0x0)); // A0.A1+A0'.A1' [5-23] (5-22 misprint)
			if (TestBit(address, 0)) // A0 [5-23]
			{
				if (isRead && TestState(StateHRamPreWrt))
				{
					ResetState(StateHRamWrt); // HRamWrt' [5-23]
				}
			}
			else
			{
				SetState(StateHRamWrt);
			}
			SetState(StateHRamPreWrt, isRead && TestBit(address, 0)); // A0.R/W' [5-22]
			MapRegionD0FF();
		}

		private void SetHires(bool value)
		{
			if (!TestState(StateHires, value))
			{
				SetState(StateHires, value);
				if (!Is80Store) // [5-7, 8-19]
				{
					MapRegion02BF();
					_video.DirtyScreen();
				}
				else
				{
					MapRegion203F();
				}
			}
		}

		private void SetMixed(bool value)
		{
			if (!TestState(StateMixed, value))
			{
				SetState(StateMixed, value);
				MapRegion02BF();
				_video.DirtyScreen();
			}
		}

		private void SetPage2(bool value)
		{
			if (!TestState(StatePage2, value))
			{
				SetState(StatePage2, value);
				if (!Is80Store) // [5-7, 8-19]
				{
					MapRegion02BF();
					_video.DirtyScreen();
				}
				else
				{
					MapRegion0407();
					MapRegion203F();
				}
			}
		}

		private void SetRamRead(bool value)
		{
			if (!TestState(StateRamRd, value))
			{
				SetState(StateRamRd, value);
				MapRegion02BF();
			}
		}

		private void SetRamWrite(bool value)
		{
			if (!TestState(StateRamWrt, value))
			{
				SetState(StateRamWrt, value);
				MapRegion02BF();
			}
		}

		private void SetRomC1CF(bool value)
		{
			if (!TestState(StateIntCXRom, value))
			{
				SetState(StateIntCXRom, value);
				MapRegionC0CF();
			}
		}

		private void SetRomC3C3(bool value)
		{
			if (!TestState(StateSlotC3Rom, value))
			{
				SetState(StateSlotC3Rom, value);
				MapRegionC0CF();
			}
		}

		private void SetRomC8CF(bool value)
		{
			if (!TestState(StateIntC8Rom, value))
			{
				SetState(StateIntC8Rom, value);
				MapRegionC0CF();
			}
		}

		private void SetText(bool value)
		{
			if (!TestState(StateText, value))
			{
				SetState(StateText, value);
				MapRegion02BF();
				_video.DirtyScreen();
			}
		}

		private void SetZeroPage(bool value)
		{
			if (!TestState(StateAltZP, value))
			{
				SetState(StateAltZP, value);
				MapRegion0001();
				MapRegionD0FF();
			}
		}

		private static int SetBit7(int data, bool value)
		{
			return value ? data | 0x80 : data & 0x7F;
		}

		private static bool TestBit(int data, int bit)
		{
			return (data & (0x1 << bit)) != 0x0;
		}

		private static bool TestMask(int data, int mask, int value)
		{
			return (data & mask) == value;
		}

		private void ResetState(int mask)
		{
			_state &= ~mask;
		}

		private void SetState(int mask)
		{
			_state |= mask;
		}

		private void SetState(int mask, bool value)
		{
			if (value)
			{
				_state |= mask;
			}
			else
			{
				_state &= ~mask;
			}
		}

		private bool TestState(int mask)
		{
			return (_state & mask) != 0x0;
		}

		private bool TestState(int mask, bool value)
		{
			return ((_state & mask) != 0x0) == value;
		}

		private bool TestState(int mask, int value)
		{
			return (_state & mask) == value;
		}

		private bool Is80Columns => TestState(State80Col);
		private bool Is80Store => TestState(State80Store);
		public bool IsCharSetAlternate => TestState(StateAltChrSet);
		private bool IsHighRamAux => IsZeroPageAux;
		private bool IsHighRamBank1 => TestState(StateBank1);
		private bool IsHighRamRead => TestState(StateHRamRd);
		private bool IsHighRamWrite => !TestState(StateHRamWrt); // HRamWrt' [5-23]
		public bool IsHires => TestState(StateHires);
		public bool IsMixed => TestState(StateMixed);
		internal bool IsPage2 => TestState(StatePage2);
		internal bool IsRamReadAux => TestState(StateRamRd);
		internal bool IsRamReadAuxRegion0407 => Is80Store ? IsPage2 : IsRamReadAux;
		internal bool IsRamReadAuxRegion203F => TestState(State80Store | StateHires, State80Store | StateHires) ? IsPage2 : IsRamReadAux;
		internal bool IsRamWriteAux => TestState(StateRamWrt);
		internal bool IsRamWriteAuxRegion0407 => Is80Store ? IsPage2 : IsRamWriteAux;
		internal bool IsRamWriteAuxRegion203F => TestState(State80Store | StateHires, State80Store | StateHires) ? IsPage2 : IsRamWriteAux;
		internal bool IsRomC1CFInternal => TestState(StateIntCXRom);
		internal bool IsRomC3C3External => TestState(StateSlotC3Rom);
		internal bool IsRomC8CFInternal => TestState(StateIntC8Rom);
		public bool IsText => TestState(StateText);
		public bool IsVideoPage2 => TestState(State80Store | StatePage2, StatePage2); // 80Store inhibits video Page2 [5-7, 8-19]
		internal bool IsZeroPageAux => TestState(StateAltZP);

		public MonitorType Monitor { get; private set; }
		public int VideoMode => StateVideoMode[_state & StateVideo];

		private Action<int, byte> _writeIoRegionC0C0;
		private Action<int, byte> _writeIoRegionC1C7;
		private Action<int, byte> _writeIoRegionC3C3;
		private Action<int, byte> _writeIoRegionC8CF;
		private Action<int, byte> _writeRomRegionD0FF;
		
		public Action<uint> ReadCallback;
		public Action<uint> WriteCallback;
		public Action<uint> ExecuteCallback;
		public Action InputCallback;
	}
}