diff --git a/Z80/inc/Z80.h b/Z80/inc/Z80.h
index 7bf1843..3c2a9ce 100644
--- a/Z80/inc/Z80.h
+++ b/Z80/inc/Z80.h
@@ -19,7 +19,7 @@ namespace EightBit {
 			bool high : 1;
 			uint8_t variable : 7;
 
-			refresh_t(uint8_t value)
+			refresh_t(const uint8_t value)
 			: high((value & Bit7) != 0),
 			  variable(value & Mask7)
 			{ }
@@ -125,7 +125,7 @@ namespace EightBit {
 			m_displacement = fetchByte();
 		}
 
-		uint8_t R(int r, uint8_t a) {
+		uint8_t R(const int r, const uint8_t a) {
 			ASSUME(r >= 0);
 			ASSUME(r <= 7);
 			switch (r) {
@@ -142,7 +142,7 @@ namespace EightBit {
 			case 5:
 				return HL2().low;
 			case 6:
-				return BUS().read(LIKELY(!m_displaced) ? HL().word : displacedAddress());
+				return BUS().read(UNLIKELY(m_displaced) ?  displacedAddress() : HL().word);
 			case 7:
 				return a;
 			default:
@@ -150,7 +150,7 @@ namespace EightBit {
 			}
 		}
 
-		void R(int r, uint8_t& a, uint8_t value) {
+		void R(const int r, uint8_t& a, const uint8_t value) {
 			ASSUME(r >= 0);
 			ASSUME(r <= 7);
 			switch (r) {
@@ -173,7 +173,7 @@ namespace EightBit {
 				HL2().low = value;
 				break;
 			case 6:
-				BUS().write(LIKELY(!m_displaced) ? HL().word : displacedAddress(), value);
+				BUS().write(UNLIKELY(m_displaced) ? displacedAddress() : HL().word, value);
 				break;
 			case 7:
 				a = value;
@@ -183,7 +183,7 @@ namespace EightBit {
 			}
 		}
 
-		uint8_t R2(int r, uint8_t a) {
+		uint8_t R2(const int r, const uint8_t a) {
 			ASSUME(r >= 0);
 			ASSUME(r <= 7);
 			switch (r) {
@@ -208,7 +208,7 @@ namespace EightBit {
 			}
 		}
 
-		void R2(int r, uint8_t& a, uint8_t value) {
+		void R2(const int r, uint8_t& a, const uint8_t value) {
 			ASSUME(r >= 0);
 			ASSUME(r <= 7);
 			switch (r) {
@@ -241,7 +241,7 @@ namespace EightBit {
 			}
 		}
 
-		register16_t& RP(int rp) {
+		register16_t& RP(const int rp) {
 			ASSUME(rp >= 0);
 			ASSUME(rp <= 3);
 			switch (rp) {
@@ -267,7 +267,7 @@ namespace EightBit {
 			return IY();
 		}
 
-		register16_t& RP2(int rp) {
+		register16_t& RP2(const int rp) {
 			ASSUME(rp >= 0);
 			ASSUME(rp <= 3);
 			switch (rp) {
@@ -284,28 +284,28 @@ namespace EightBit {
 			}
 		}
 
-		static void adjustHalfCarryAdd(uint8_t& f, uint8_t before, uint8_t value, int calculation) {
+		static void adjustHalfCarryAdd(uint8_t& f, const uint8_t before, const uint8_t value, const int calculation) {
 			setFlag(f, HC, calculateHalfCarryAdd(before, value, calculation));
 		}
 
-		static void adjustHalfCarrySub(uint8_t& f, uint8_t before, uint8_t value, int calculation) {
+		static void adjustHalfCarrySub(uint8_t& f, const uint8_t before, const uint8_t value, const int calculation) {
 			setFlag(f, HC, calculateHalfCarrySub(before, value, calculation));
 		}
 
-		static void adjustOverflowAdd(uint8_t& f, uint8_t before, uint8_t value, uint8_t calculation) {
+		static void adjustOverflowAdd(uint8_t& f, const uint8_t before, const uint8_t value, const uint8_t calculation) {
 			adjustOverflowAdd(f, before & SF, value & SF, calculation & SF);
 		}
 
-		static void adjustOverflowAdd(uint8_t& f, int beforeNegative, int valueNegative, int afterNegative) {
+		static void adjustOverflowAdd(uint8_t& f, const int beforeNegative, const int valueNegative, const int afterNegative) {
 			auto overflow = (beforeNegative == valueNegative) && (beforeNegative != afterNegative);
 			setFlag(f, VF, overflow);
 		}
 
-		static void adjustOverflowSub(uint8_t& f, uint8_t before, uint8_t value, uint8_t calculation) {
+		static void adjustOverflowSub(uint8_t& f, const uint8_t before, const uint8_t value, const uint8_t calculation) {
 			adjustOverflowSub(f, before & SF, value & SF, calculation & SF);
 		}
 
-		static void adjustOverflowSub(uint8_t& f, int beforeNegative, int valueNegative, int afterNegative) {
+		static void adjustOverflowSub(uint8_t& f, const int beforeNegative, const int valueNegative, const int afterNegative) {
 			auto overflow = (beforeNegative != valueNegative) && (beforeNegative != afterNegative);
 			setFlag(f, VF, overflow);
 		}
diff --git a/Z80/src/Z80.cpp b/Z80/src/Z80.cpp
index 28ccb2a..b58603a 100644
--- a/Z80/src/Z80.cpp
+++ b/Z80/src/Z80.cpp
@@ -73,7 +73,7 @@ void EightBit::Z80::decrement(uint8_t& f, uint8_t& operand) {
 	setFlag(f, VF, operand == Mask7);
 }
 
-bool EightBit::Z80::jrConditionalFlag(uint8_t f, const int flag) {
+bool EightBit::Z80::jrConditionalFlag(const uint8_t f, const int flag) {
 	ASSUME(flag >= 0);
 	ASSUME(flag <= 3);
 	switch (flag) {
@@ -90,7 +90,7 @@ bool EightBit::Z80::jrConditionalFlag(uint8_t f, const int flag) {
 	}
 }
 
-bool EightBit::Z80::jumpConditionalFlag(uint8_t f, const int flag) {
+bool EightBit::Z80::jumpConditionalFlag(const uint8_t f, const int flag) {
 	ASSUME(flag >= 0);
 	ASSUME(flag <= 7);
 	switch (flag) {
@@ -125,7 +125,7 @@ void EightBit::Z80::reti() {
 	retn();
 }
 
-bool EightBit::Z80::returnConditionalFlag(uint8_t f, const int flag) {
+bool EightBit::Z80::returnConditionalFlag(const uint8_t f, const int flag) {
 	ASSUME(flag >= 0);
 	ASSUME(flag <= 7);
 	switch (flag) {
@@ -150,7 +150,7 @@ bool EightBit::Z80::returnConditionalFlag(uint8_t f, const int flag) {
 	}
 }
 
-bool EightBit::Z80::callConditionalFlag(uint8_t f, const int flag) {
+bool EightBit::Z80::callConditionalFlag(const uint8_t f, const int flag) {
 	ASSUME(flag >= 0);
 	ASSUME(flag <= 7);
 	switch (flag) {
@@ -372,7 +372,7 @@ uint8_t EightBit::Z80::srl(uint8_t& f, uint8_t operand) {
 	return operand;
 }
 
-uint8_t EightBit::Z80::bit(uint8_t& f, int n, uint8_t operand) {
+uint8_t EightBit::Z80::bit(uint8_t& f, const int n, const uint8_t operand) {
 	ASSUME(n >= 0);
 	ASSUME(n <= 7);
 	setFlag(f, HC);
@@ -383,13 +383,13 @@ uint8_t EightBit::Z80::bit(uint8_t& f, int n, uint8_t operand) {
 	return operand;
 }
 
-uint8_t EightBit::Z80::res(int n, const uint8_t operand) {
+uint8_t EightBit::Z80::res(const int n, const uint8_t operand) {
 	ASSUME(n >= 0);
 	ASSUME(n <= 7);
 	return operand & ~(1 << n);
 }
 
-uint8_t EightBit::Z80::set(int n, const uint8_t operand) {
+uint8_t EightBit::Z80::set(const int n, const uint8_t operand) {
 	ASSUME(n >= 0);
 	ASSUME(n <= 7);
 	return operand | (1 << n);
@@ -710,15 +710,15 @@ int EightBit::Z80::execute(const uint8_t opcode) {
 	auto& f = af.low;
 
 	auto prefixed = m_prefixCB || m_prefixED;
-	if (LIKELY(!prefixed)) {
-		executeOther(a, f, x, y, z, p, q);
-	} else {
+	if (UNLIKELY(prefixed)) {
 		if (m_prefixCB)
 			executeCB(a, f, x, y, z);
 		else if (m_prefixED)
 			executeED(a, f, x, y, z, p, q);
 		else
 			UNREACHABLE;
+	} else {
+		executeOther(a, f, x, y, z, p, q);
 	}
 
 	ASSUME(cycles() > 0);
@@ -764,21 +764,25 @@ void EightBit::Z80::executeCB(uint8_t& a, uint8_t& f, const int x, const int y,
 			UNREACHABLE;
 		}
 		adjustSZP<Z80>(f, operand);
-		if (LIKELY(!m_displaced)) {
-			R(z, a, operand);
-			if (UNLIKELY(z == 6))
-				addCycles(7);
-		} else {
+		if (UNLIKELY(m_displaced)) {
 			if (LIKELY(z != 6))
 				R2(z, a, operand);
 			BUS().write(operand);
 			addCycles(15);
+		} else {
+			R(z, a, operand);
+			if (UNLIKELY(z == 6))
+				addCycles(7);
 		}
 		addCycles(8);
 		break;
 	} case 1:	// BIT y, r[z]
 		addCycles(8);
-		if (LIKELY(!m_displaced)) {
+		if (UNLIKELY(m_displaced)) {
+			bit(f, y, BUS().read(displacedAddress()));
+			adjustXY<Z80>(f, MEMPTR().high);
+			addCycles(12);
+		} else {
 			const auto operand = bit(f, y, R(z, a));
 			if (UNLIKELY(z == 6)) {
 				adjustXY<Z80>(f, MEMPTR().high);
@@ -786,38 +790,34 @@ void EightBit::Z80::executeCB(uint8_t& a, uint8_t& f, const int x, const int y,
 			} else {
 				adjustXY<Z80>(f, operand);
 			}
-		} else {
-			bit(f, y, BUS().read(displacedAddress()));
-			adjustXY<Z80>(f, MEMPTR().high);
-			addCycles(12);
 		}
 		break;
 	case 2:	// RES y, r[z]
 		addCycles(8);
-		if (LIKELY(!m_displaced)) {
-			R(z, a, res(y, R(z, a)));
-			if (UNLIKELY(z == 6))
-				addCycles(7);
-		} else {
+		if (UNLIKELY(m_displaced)) {
 			auto operand = BUS().read(displacedAddress());
 			operand = res(y, operand);
 			BUS().write(operand);
 			R2(z, a, operand);
 			addCycles(15);
+		} else {
+			R(z, a, res(y, R(z, a)));
+			if (UNLIKELY(z == 6))
+				addCycles(7);
 		}
 		break;
 	case 3:	// SET y, r[z]
 		addCycles(8);
-		if (LIKELY(!m_displaced)) {
-			R(z, a, set(y, R(z, a)));
-			if (UNLIKELY(z == 6))
-				addCycles(7);
-		} else {
+		if (UNLIKELY(m_displaced)) {
 			auto operand = BUS().read(displacedAddress());
 			operand = set(y, operand);
 			BUS().write(operand);
 			R2(z, a, operand);
 			addCycles(15);
+		} else {
+			R(z, a, set(y, R(z, a)));
+			if (UNLIKELY(z == 6))
+				addCycles(7);
 		}
 		break;
 	default:
@@ -1222,22 +1222,24 @@ void EightBit::Z80::executeOther(uint8_t& a, uint8_t& f, const int x, const int
 			addCycles(4);
 			break;
 		} case 5: {	// 8-bit DEC
-			if (UNLIKELY(m_displaced && (y == 6)))
-				fetchDisplacement();
+			if (UNLIKELY(y == 6)) {
+				addCycles(7);
+				if (UNLIKELY(m_displaced))
+					fetchDisplacement();
+			}
 			auto operand = R(y, a);
 			decrement(f, operand);
 			R(y, a, operand);
 			addCycles(4);
-			if (UNLIKELY(y == 6))
-				addCycles(7);
 			break;
 		} case 6:	// 8-bit load immediate
-			if (UNLIKELY(m_displaced && (y == 6)))
-				fetchDisplacement();
+			if (UNLIKELY(y == 6)) {
+				addCycles(3);
+				if (UNLIKELY(m_displaced))
+					fetchDisplacement();
+			}
 			R(y, a, fetchByte());	// LD r,n
 			addCycles(7);
-			if (UNLIKELY(y == 6))
-				addCycles(3);
 			break;
 		case 7:	// Assorted operations on accumulator/flags
 			switch (y) {
@@ -1315,8 +1317,11 @@ void EightBit::Z80::executeOther(uint8_t& a, uint8_t& f, const int x, const int
 		addCycles(4);
 		break;
 	case 2:	// Operate on accumulator and register/memory location
-		if (UNLIKELY(m_displaced && (z == 6)))
-			fetchDisplacement();
+		if (UNLIKELY(z == 6)) {
+			addCycles(3);
+			if (UNLIKELY(m_displaced))
+				fetchDisplacement();
+		}
 		switch (y) {
 		case 0:	// ADD A,r
 			add(f, a, R(z, a));
@@ -1346,8 +1351,6 @@ void EightBit::Z80::executeOther(uint8_t& a, uint8_t& f, const int x, const int
 			UNREACHABLE;
 		}
 		addCycles(4);
-		if (UNLIKELY(z == 6))
-			addCycles(3);
 		break;
 	case 3:
 		switch (z) {
diff --git a/inc/InputOutput.h b/inc/InputOutput.h
index 80aedeb..8e8ddc3 100644
--- a/inc/InputOutput.h
+++ b/inc/InputOutput.h
@@ -6,17 +6,17 @@
 #include "Signal.h"
 
 namespace EightBit {
-	class InputOutput {
+	class InputOutput final {
 	public:
 		InputOutput() = default;
 
-		uint8_t read(uint8_t port) { return readInputPort(port); }
-		void write(uint8_t port, uint8_t value) { return writeOutputPort(port, value); }
+		uint8_t read(const uint8_t port) { return readInputPort(port); }
+		void write(const uint8_t port, const uint8_t value) { return writeOutputPort(port, value); }
 
 		uint8_t readInputPort(uint8_t port);
-		void writeInputPort(uint8_t port, uint8_t value) { m_input[port] = value; }
+		void writeInputPort(const uint8_t port, const uint8_t value) { m_input[port] = value; }
 
-		uint8_t readOutputPort(uint8_t port) { return m_output[port]; }
+		uint8_t readOutputPort(const uint8_t port) { return m_output[port]; }
 		void writeOutputPort(uint8_t port, uint8_t value);
 
 		Signal<uint8_t> ReadingPort;
diff --git a/inc/IntelProcessor.h b/inc/IntelProcessor.h
index be45208..ff4a023 100644
--- a/inc/IntelProcessor.h
+++ b/inc/IntelProcessor.h
@@ -23,7 +23,7 @@ namespace EightBit {
 
 			opcode_decoded_t() {}
 
-			opcode_decoded_t(uint8_t opcode) {
+			opcode_decoded_t(const uint8_t opcode) {
 				x = (opcode & 0b11000000) >> 6;	// 0 - 3
 				y = (opcode & 0b00111000) >> 3;	// 0 - 7
 				z = (opcode & 0b00000111);		// 0 - 7
@@ -62,56 +62,56 @@ namespace EightBit {
 
 		virtual void reset() override;
 
-		template<class T> static void adjustSign(uint8_t& f, uint8_t value) {
+		template<class T> static void adjustSign(uint8_t& f, const uint8_t value) {
 			setFlag(f, T::SF, value & T::SF);
 		}
 
-		template<class T> static void adjustZero(uint8_t& f, uint8_t value) {
+		template<class T> static void adjustZero(uint8_t& f, const uint8_t value) {
 			clearFlag(f, T::ZF, value);
 		}
 
-		template<class T> static void adjustParity(uint8_t& f, uint8_t value) {
+		template<class T> static void adjustParity(uint8_t& f, const uint8_t value) {
 			clearFlag(f, T::PF, PARITY(value));
 		}
 
-		template<class T> static void adjustSZ(uint8_t& f, uint8_t value) {
+		template<class T> static void adjustSZ(uint8_t& f, const uint8_t value) {
 			adjustSign<T>(f, value);
 			adjustZero<T>(f, value);
 		}
 
-		template<class T> static void adjustSZP(uint8_t& f, uint8_t value) {
+		template<class T> static void adjustSZP(uint8_t& f, const uint8_t value) {
 			adjustSZ<T>(f, value);
 			adjustParity<T>(f, value);
 		}
 
-		template<class T> static void adjustXY(uint8_t& f, uint8_t value) {
+		template<class T> static void adjustXY(uint8_t& f, const uint8_t value) {
 			setFlag(f, T::XF, value & T::XF);
 			setFlag(f, T::YF, value & T::YF);
 		}
 
-		template<class T> static void adjustSZPXY(uint8_t& f, uint8_t value) {
+		template<class T> static void adjustSZPXY(uint8_t& f, const uint8_t value) {
 			adjustSZP<T>(f, value);
 			adjustXY<T>(f, value);
 		}
 
-		template<class T> static void adjustSZXY(uint8_t& f, uint8_t value) {
+		template<class T> static void adjustSZXY(uint8_t& f, const uint8_t value) {
 			adjustSZ<T>(f, value);
 			adjustXY<T>(f, value);
 		}
 
 		//
 
-		static int buildHalfCarryIndex(uint8_t before, uint8_t value, int calculation) {
+		static int buildHalfCarryIndex(const uint8_t before, const uint8_t value, const int calculation) {
 			return ((before & 0x88) >> 1) | ((value & 0x88) >> 2) | ((calculation & 0x88) >> 3);
 		}
 
-		static bool calculateHalfCarryAdd(uint8_t before, uint8_t value, int calculation) {
+		static bool calculateHalfCarryAdd(const uint8_t before, const uint8_t value, const int calculation) {
 			static std::array<bool, 8> m_halfCarryTableAdd = { { false, false, true, false, true, false, true, true } };
 			const auto index = buildHalfCarryIndex(before, value, calculation);
 			return m_halfCarryTableAdd[index & Mask3];
 		}
 
-		static bool calculateHalfCarrySub(uint8_t before, uint8_t value, int calculation) {
+		static bool calculateHalfCarrySub(const uint8_t before, const uint8_t value, const int calculation) {
 			std::array<bool, 8> m_halfCarryTableSub = { { false, true, true, true, false, false, false, true } };
 			const auto index = buildHalfCarryIndex(before, value, calculation);
 			return m_halfCarryTableSub[index & Mask3];
@@ -127,27 +127,27 @@ namespace EightBit {
 
 		//
 
-		void restart(uint8_t address) {
+		void restart(const uint8_t address) {
 			MEMPTR().low = address;
 			MEMPTR().high = 0;
 			call(MEMPTR());
 		}
 
-		bool callConditional(int condition) {
+		bool callConditional(const int condition) {
 			MEMPTR() = fetchWord();
 			if (condition)
 				call(MEMPTR());
 			return condition != 0;
 		}
 
-		bool jumpConditional(int conditional) {
+		bool jumpConditional(const int conditional) {
 			MEMPTR() = fetchWord();
 			if (conditional)
 				jump(MEMPTR());
 			return conditional != 0;
 		}
 
-		bool returnConditional(int condition) {
+		bool returnConditional(const int condition) {
 			if (condition) {
 				ret();
 				MEMPTR() = PC();
@@ -155,12 +155,12 @@ namespace EightBit {
 			return condition != 0;
 		}
 
-		void jr(int8_t offset) {
+		void jr(const int8_t offset) {
 			MEMPTR().word = PC().word + offset;
 			jump(MEMPTR());
 		}
 
-		bool jrConditional(int conditional) {
+		bool jrConditional(const int conditional) {
 			const auto offset = fetchByte();
 			if (conditional)
 				jr(offset);
diff --git a/inc/Memory.h b/inc/Memory.h
index 24f5080..25ceac1 100644
--- a/inc/Memory.h
+++ b/inc/Memory.h
@@ -11,23 +11,23 @@ namespace EightBit {
 		static int load(std::ifstream& file, std::vector<uint8_t>& output, int writeOffset = 0, int readOffset = 0, int limit = -1, int maximumSize = -1);
 		static int load(const std::string& path, std::vector<uint8_t>& output, int writeOffset = 0, int readOffset = 0, int limit = -1, int maximumSize = -1);
 
-		Memory(size_t size = 0)
+		Memory(const size_t size = 0)
 		: m_bytes(size) {
 		}
 
 		size_t size() const { return m_bytes.size();  }
 
-		int load(std::ifstream& file, int writeOffset = 0, int readOffset = 0, int limit = -1) {
+		int load(std::ifstream& file, const int writeOffset = 0, const int readOffset = 0, const int limit = -1) {
 			const auto maximumSize = (int)m_bytes.size() - writeOffset;
 			return load(file, m_bytes, writeOffset, readOffset, limit, maximumSize);
 		}
 
-		int load(const std::string& path, int writeOffset = 0, int readOffset = 0, int limit = -1) {
+		int load(const std::string& path, const int writeOffset = 0, const int readOffset = 0, const int limit = -1) {
 			const auto maximumSize = (int)m_bytes.size() - writeOffset;
 			return load(path, m_bytes, writeOffset, readOffset, limit, maximumSize);
 		}
 
-		int load(const std::vector<uint8_t>& bytes, int writeOffset = 0, int readOffset = 0, int limit = -1) {
+		int load(const std::vector<uint8_t>& bytes, const int writeOffset = 0, const int readOffset = 0, int limit = -1) {
 			if (limit < 0)
 				limit = (int)bytes.size() - readOffset;
 			std::copy(bytes.cbegin() + readOffset, bytes.cbegin() + limit, m_bytes.begin() + writeOffset);
@@ -37,11 +37,11 @@ namespace EightBit {
 	protected:
 		std::vector<uint8_t>& BYTES() { return m_bytes; }
 
-		uint8_t read(uint16_t address) const {
+		uint8_t read(const uint16_t address) const {
 			return m_bytes[address];
 		}
 
-		void write(uint16_t address, uint8_t value) {
+		void write(const uint16_t address, const uint8_t value) {
 			m_bytes[address] = value;
 		}
 
diff --git a/inc/Processor.h b/inc/Processor.h
index 06f73ee..3b8dc53 100644
--- a/inc/Processor.h
+++ b/inc/Processor.h
@@ -53,16 +53,16 @@ namespace EightBit {
 			Low, High
 		};
 
-		static bool raised(PinLevel line) { return line == High; }
+		static bool raised(const PinLevel line) { return line == High; }
 		static void raise(PinLevel& line) { line = High; }
-		static bool lowered(PinLevel line) { return line == Low; }
+		static bool lowered(const PinLevel line) { return line == Low; }
 		static void lower(PinLevel& line) { line = Low; }
 
-		static int highNibble(int value) { return value >> 4; }
-		static int lowNibble(int value) { return value & Mask4; }
+		static int highNibble(const int value) { return value >> 4; }
+		static int lowNibble(const int value) { return value & Mask4; }
 
-		static int promoteNibble(int value) { return value << 4; }
-		static int demoteNibble(int value) { return highNibble(value); }
+		static int promoteNibble(const int value) { return value << 4; }
+		static int demoteNibble(const int value) { return highNibble(value); }
 
 		Bus& BUS() { return m_bus; }
 
@@ -85,16 +85,16 @@ namespace EightBit {
 		virtual int execute(uint8_t opcode) = 0;
 
 	protected:
-		static void clearFlag(uint8_t& f, int flag) { f &= ~flag; }
-		static void setFlag(uint8_t& f, int flag) { f |= flag; }
+		static void clearFlag(uint8_t& f, const int flag) { f &= ~flag; }
+		static void setFlag(uint8_t& f, const int flag) { f |= flag; }
 
-		static void setFlag(uint8_t& f, int flag, int condition) { setFlag(f, flag, condition != 0); }
-		static void setFlag(uint8_t& f, int flag, uint32_t condition) { setFlag(f, flag, condition != 0); }
-		static void setFlag(uint8_t& f, int flag, bool condition) { condition ? setFlag(f, flag) : clearFlag(f, flag); }
+		static void setFlag(uint8_t& f, const int flag, const int condition) { setFlag(f, flag, condition != 0); }
+		static void setFlag(uint8_t& f, const int flag, const uint32_t condition) { setFlag(f, flag, condition != 0); }
+		static void setFlag(uint8_t& f, const int flag, const bool condition) { condition ? setFlag(f, flag) : clearFlag(f, flag); }
 
-		static void clearFlag(uint8_t& f, int flag, int condition) { clearFlag(f, flag, condition != 0); }
-		static void clearFlag(uint8_t& f, int flag, uint32_t condition) { clearFlag(f, flag, condition != 0); }
-		static void clearFlag(uint8_t& f, int flag, bool condition) { condition ? clearFlag(f, flag) : setFlag(f, flag); }
+		static void clearFlag(uint8_t& f, const int flag, const int condition) { clearFlag(f, flag, condition != 0); }
+		static void clearFlag(uint8_t& f, const int flag, const uint32_t condition) { clearFlag(f, flag, condition != 0); }
+		static void clearFlag(uint8_t& f, const int flag, const bool condition) { condition ? clearFlag(f, flag) : setFlag(f, flag); }
 
 		Processor(Bus& memory);
 		virtual ~Processor() = default;
@@ -119,7 +119,7 @@ namespace EightBit {
 		virtual void push(uint8_t value) = 0;
 		virtual uint8_t pop() = 0;
 
-		void pushWord(register16_t value) {
+		void pushWord(const register16_t value) {
 			push(value.high);
 			push(value.low);
 		}
@@ -131,11 +131,11 @@ namespace EightBit {
 			return returned;
 		}
 
-		void jump(register16_t destination) {
+		void jump(const register16_t destination) {
 			PC() = destination;
 		}
 
-		void call(register16_t destination) {
+		void call(const register16_t destination) {
 			pushWord(PC());
 			jump(destination);
 		}
@@ -146,7 +146,7 @@ namespace EightBit {
 
 		int cycles() const { return m_cycles; }
 		void resetCycles() { m_cycles = 0; }
-		void addCycles(int extra) { m_cycles += extra; }
+		void addCycles(const int extra) { m_cycles += extra; }
 		void addCycle() { ++m_cycles;  }
 
 	private:
diff --git a/inc/Ram.h b/inc/Ram.h
index 903c37d..5040a33 100644
--- a/inc/Ram.h
+++ b/inc/Ram.h
@@ -6,19 +6,19 @@
 namespace EightBit {
 	class Ram : public Memory {
 	public:
-		Ram(size_t size = 0)
+		Ram(const size_t size = 0)
 		: Memory(size) {
 		}
 
-		uint8_t peek(uint16_t address) const {
+		uint8_t peek(const uint16_t address) const {
 			return read(address);
 		}
 
-		void poke(uint16_t address, uint8_t value) {
+		void poke(const uint16_t address, const uint8_t value) {
 			write(address, value);
 		}
 
-		uint8_t& reference(uint16_t address) {
+		uint8_t& reference(const uint16_t address) {
 			return BYTES()[address];
 		}
 	};
diff --git a/inc/Rom.h b/inc/Rom.h
index c2d2506..8a1b45a 100644
--- a/inc/Rom.h
+++ b/inc/Rom.h
@@ -6,15 +6,15 @@
 namespace EightBit {
 	class Rom : public Memory {
 	public:
-		Rom(size_t size = 0)
+		Rom(const size_t size = 0)
 		: Memory(size) {
 		}
 
-		uint8_t peek(uint16_t address) const {
+		uint8_t peek(const uint16_t address) const {
 			return read(address);
 		}
 
-		uint8_t& reference(uint16_t address) {
+		uint8_t& reference(const uint16_t address) {
 			return BYTES()[address];
 		}
 	};
diff --git a/inc/Signal.h b/inc/Signal.h
index c5df1c7..ebc7a09 100644
--- a/inc/Signal.h
+++ b/inc/Signal.h
@@ -4,7 +4,7 @@
 #include <functional>
 
 namespace EightBit {
-	template<class T> class Signal {
+	template<class T> class Signal final {
 	private:
 		typedef std::function<void(const T&)> delegate_t;
 		typedef std::vector<delegate_t> delegates_t;
@@ -12,7 +12,7 @@ namespace EightBit {
 		delegates_t m_delegates;
 
 	public:
-		void connect(delegate_t functor) {
+		void connect(const delegate_t functor) {
 			m_delegates.push_back(functor);
 		}
 
diff --git a/inc/TestHarness.h b/inc/TestHarness.h
index 62b77f3..c7a84bd 100644
--- a/inc/TestHarness.h
+++ b/inc/TestHarness.h
@@ -18,11 +18,7 @@ namespace EightBit {
 	template<class ConfigurationT, class BoardT> class TestHarness {
 	public:
 		TestHarness(const ConfigurationT& configuration)
-		: m_board(configuration),
-		  m_totalCycles(0),
-		  m_instructions(0),
-		  m_startHostCycles(0),
-		  m_finishHostCycles(0) {
+		: m_board(configuration) {
 		}
 
 		~TestHarness() {
@@ -81,12 +77,12 @@ namespace EightBit {
 
 	private:
 		BoardT m_board;
-		long long m_totalCycles;
-		long long m_instructions;
+		long long m_totalCycles = 0;
+		long long m_instructions = 0;
 		std::chrono::steady_clock::time_point m_startTime;
 		std::chrono::steady_clock::time_point m_finishTime;
-		uint64_t m_startHostCycles;
-		uint64_t m_finishHostCycles;
+		uint64_t m_startHostCycles = 0;
+		uint64_t m_finishHostCycles = 0;
 
 		static std::chrono::steady_clock::time_point now() {
 			return std::chrono::steady_clock::now();
diff --git a/src/Bus.cpp b/src/Bus.cpp
index 3bc3b62..ddfabe0 100644
--- a/src/Bus.cpp
+++ b/src/Bus.cpp
@@ -11,7 +11,7 @@ uint8_t& EightBit::Bus::DATA() {
 	return *m_data;
 }
 
-uint8_t& EightBit::Bus::placeDATA(uint8_t value) {
+uint8_t& EightBit::Bus::placeDATA(const uint8_t value) {
 	m_temporary = value;
 	m_data = &m_temporary;
 	return DATA();
@@ -22,17 +22,17 @@ uint8_t& EightBit::Bus::referenceDATA(uint8_t& value) {
 	return DATA();
 }
 
-uint8_t EightBit::Bus::peek(uint16_t address) {
+uint8_t EightBit::Bus::peek(const uint16_t address) {
 	bool rom;
 	return reference(address, rom);
 }
 
-void EightBit::Bus::poke(uint16_t address, uint8_t value) {
+void EightBit::Bus::poke(const uint16_t address, const uint8_t value) {
 	bool rom;
 	reference(address, rom) = value;
 }
 
-uint16_t EightBit::Bus::peekWord(uint16_t address) {
+uint16_t EightBit::Bus::peekWord(const uint16_t address) {
 	register16_t returned;
 	returned.low = peek(address);
 	returned.high = peek(address + 1);
@@ -46,28 +46,28 @@ uint8_t EightBit::Bus::read() {
 	return returned;
 }
 
-uint8_t EightBit::Bus::read(uint16_t offset) {
+uint8_t EightBit::Bus::read(const uint16_t offset) {
 	ADDRESS().word = offset;
 	return read();
 }
 
-uint8_t EightBit::Bus::read(register16_t address) {
+uint8_t EightBit::Bus::read(const register16_t address) {
 	ADDRESS() = address;
 	return read();
 }
 
-void EightBit::Bus::write(uint8_t value) {
+void EightBit::Bus::write(const uint8_t value) {
 	WritingByte.fire(ADDRESS().word);
 	reference() = value;
 	WrittenByte.fire(ADDRESS().word);
 }
 
-void EightBit::Bus::write(uint16_t offset, uint8_t value) {
+void EightBit::Bus::write(const uint16_t offset, const uint8_t value) {
 	ADDRESS().word = offset;
 	write(value);
 }
 
-void EightBit::Bus::write(register16_t address, uint8_t value) {
+void EightBit::Bus::write(const register16_t address, const uint8_t value) {
 	ADDRESS() = address;
 	write(value);
 }
@@ -75,5 +75,5 @@ void EightBit::Bus::write(register16_t address, uint8_t value) {
 uint8_t& EightBit::Bus::reference() {
 	bool rom;
 	auto& value = reference(ADDRESS().word, rom);
-	return LIKELY(!rom) ? referenceDATA(value) : placeDATA(value);
+	return rom ? placeDATA(value) : referenceDATA(value);
 }
diff --git a/src/InputOutput.cpp b/src/InputOutput.cpp
index 7541b9a..b406d18 100644
--- a/src/InputOutput.cpp
+++ b/src/InputOutput.cpp
@@ -1,31 +1,31 @@
 #include "stdafx.h"
 #include "InputOutput.h"
 
-uint8_t EightBit::InputOutput::readInputPort(uint8_t port) {
+uint8_t EightBit::InputOutput::readInputPort(const uint8_t port) {
 	OnReadingPort(port);
 	const auto value = m_input[port];
 	OnReadPort(port);
 	return value;
 }
 
-void EightBit::InputOutput::writeOutputPort(uint8_t port, uint8_t value) {
+void EightBit::InputOutput::writeOutputPort(const uint8_t port, const uint8_t value) {
 	OnWritingPort(port);
 	m_output[port] = value;
 	OnWrittenPort(port);
 }
 
-void EightBit::InputOutput::OnReadingPort(uint8_t port) {
+void EightBit::InputOutput::OnReadingPort(const uint8_t port) {
 	ReadingPort.fire(port);
 }
 
-void EightBit::InputOutput::OnReadPort(uint8_t port) {
+void EightBit::InputOutput::OnReadPort(const uint8_t port) {
 	ReadPort.fire(port);
 }
 
-void EightBit::InputOutput::OnWritingPort(uint8_t port) {
+void EightBit::InputOutput::OnWritingPort(const uint8_t port) {
 	WritingPort.fire(port);
 }
 
-void EightBit::InputOutput::OnWrittenPort(uint8_t port) {
+void EightBit::InputOutput::OnWrittenPort(const uint8_t port) {
 	WrittenPort.fire(port);
 }
diff --git a/src/IntelProcessor.cpp b/src/IntelProcessor.cpp
index b14f07f..778dde0 100644
--- a/src/IntelProcessor.cpp
+++ b/src/IntelProcessor.cpp
@@ -12,7 +12,7 @@ void EightBit::IntelProcessor::reset() {
 	SP().word = AF().word = BC().word = DE().word = HL().word = Mask16;
 }
 
-void EightBit::IntelProcessor::push(uint8_t value) {
+void EightBit::IntelProcessor::push(const uint8_t value) {
 	BUS().write(--SP().word, value);
 }
 
@@ -27,7 +27,7 @@ EightBit::register16_t EightBit::IntelProcessor::getWord() {
 	return returned;
 }
 
-void EightBit::IntelProcessor::setWord(register16_t value) {
+void EightBit::IntelProcessor::setWord(const register16_t value) {
 	BUS().write(MEMPTR().word++, value.low);
 	BUS().write(++BUS().ADDRESS().word, value.high);
 }
diff --git a/src/Processor.cpp b/src/Processor.cpp
index b2103a6..3eb1c6a 100644
--- a/src/Processor.cpp
+++ b/src/Processor.cpp
@@ -14,7 +14,7 @@ void EightBit::Processor::reset() {
 	PC().word = 0;
 }
 
-int EightBit::Processor::run(int limit) {
+int EightBit::Processor::run(const int limit) {
 	int current = 0;
 	while (LIKELY(powered()) && current < limit) {
 		current += singleStep();