diff --git a/Machines/Acorn/Archimedes/Archimedes.cpp b/Machines/Acorn/Archimedes/Archimedes.cpp
index 1b921f254..7357f30fa 100644
--- a/Machines/Acorn/Archimedes/Archimedes.cpp
+++ b/Machines/Acorn/Archimedes/Archimedes.cpp
@@ -750,9 +750,9 @@ private:
 using namespace Archimedes;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	const auto archimedes_target = dynamic_cast<const Analyser::Static::Acorn::ArchimedesTarget *>(target);
-	return std::make_unique<ConcreteMachine>(*archimedes_target, rom_fetcher);
+	const auto &archimedes_target = static_cast<const Analyser::Static::Acorn::ArchimedesTarget &>(target);
+	return std::make_unique<ConcreteMachine>(archimedes_target, rom_fetcher);
 }
diff --git a/Machines/Acorn/Archimedes/Archimedes.hpp b/Machines/Acorn/Archimedes/Archimedes.hpp
index cbc7d08f8..9c0e76d81 100644
--- a/Machines/Acorn/Archimedes/Archimedes.hpp
+++ b/Machines/Acorn/Archimedes/Archimedes.hpp
@@ -19,10 +19,7 @@ namespace Archimedes {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(
-		const Analyser::Static::Target *target,
-		const ROMMachine::ROMFetcher &rom_fetcher
-	);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::QuickLoad<Options> {
 		friend Configurable::Options::QuickLoad<Options>;
diff --git a/Machines/Acorn/BBCMicro/BBCMicro.cpp b/Machines/Acorn/BBCMicro/BBCMicro.cpp
index 9e976c6b3..2d487549c 100644
--- a/Machines/Acorn/BBCMicro/BBCMicro.cpp
+++ b/Machines/Acorn/BBCMicro/BBCMicro.cpp
@@ -1350,14 +1350,14 @@ std::unique_ptr<Machine> machine(const Target &target, const ROMMachine::ROMFetc
 }
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	const Target *const acorn_target = dynamic_cast<const Target *>(target);
-	switch(acorn_target->tube_processor) {
-		case TubeProcessor::None:		return machine<TubeProcessor::None>(*acorn_target, rom_fetcher);
-		case TubeProcessor::WDC65C02:	return machine<TubeProcessor::WDC65C02>(*acorn_target, rom_fetcher);
-		case TubeProcessor::Z80:		return machine<TubeProcessor::Z80>(*acorn_target, rom_fetcher);
+	const auto &acorn_target = static_cast<const Target &>(target);
+	switch(acorn_target.tube_processor) {
+		case TubeProcessor::None:		return machine<TubeProcessor::None>(acorn_target, rom_fetcher);
+		case TubeProcessor::WDC65C02:	return machine<TubeProcessor::WDC65C02>(acorn_target, rom_fetcher);
+		case TubeProcessor::Z80:		return machine<TubeProcessor::Z80>(acorn_target, rom_fetcher);
 		default:	return nullptr;
 	}
 }
diff --git a/Machines/Acorn/BBCMicro/BBCMicro.hpp b/Machines/Acorn/BBCMicro/BBCMicro.hpp
index 96258f3d9..d511c21a6 100644
--- a/Machines/Acorn/BBCMicro/BBCMicro.hpp
+++ b/Machines/Acorn/BBCMicro/BBCMicro.hpp
@@ -20,7 +20,7 @@ namespace BBCMicro {
 struct Machine {
 	virtual ~Machine() = default;
 
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,
diff --git a/Machines/Acorn/Electron/Electron.cpp b/Machines/Acorn/Electron/Electron.cpp
index 8232e7a0a..95764ed1a 100644
--- a/Machines/Acorn/Electron/Electron.cpp
+++ b/Machines/Acorn/Electron/Electron.cpp
@@ -793,15 +793,15 @@ private:
 using namespace Electron;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::Acorn::ElectronTarget;
-	const Target *const acorn_target = dynamic_cast<const Target *>(target);
+	const auto &acorn_target = static_cast<const Target &>(target);
 
-	if(acorn_target->media.mass_storage_devices.empty()) {
-		return std::make_unique<Electron::ConcreteMachine<false>>(*acorn_target, rom_fetcher);
+	if(acorn_target.media.mass_storage_devices.empty()) {
+		return std::make_unique<Electron::ConcreteMachine<false>>(acorn_target, rom_fetcher);
 	} else {
-		return std::make_unique<Electron::ConcreteMachine<true>>(*acorn_target, rom_fetcher);
+		return std::make_unique<Electron::ConcreteMachine<true>>(acorn_target, rom_fetcher);
 	}
 }
diff --git a/Machines/Acorn/Electron/Electron.hpp b/Machines/Acorn/Electron/Electron.hpp
index 86f523870..b8856fa61 100644
--- a/Machines/Acorn/Electron/Electron.hpp
+++ b/Machines/Acorn/Electron/Electron.hpp
@@ -27,7 +27,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Electron.
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options available for an Electron.
 	class Options:
diff --git a/Machines/Amiga/Amiga.cpp b/Machines/Amiga/Amiga.cpp
index 907dfebfa..32ba4282d 100644
--- a/Machines/Amiga/Amiga.cpp
+++ b/Machines/Amiga/Amiga.cpp
@@ -252,10 +252,10 @@ private:
 using namespace Amiga;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::Amiga::Target;
-	const Target *const amiga_target = dynamic_cast<const Target *>(target);
-	return std::make_unique<Amiga::ConcreteMachine>(*amiga_target, rom_fetcher);
+	const auto &amiga_target = static_cast<const Target &>(target);
+	return std::make_unique<Amiga::ConcreteMachine>(amiga_target, rom_fetcher);
 }
diff --git a/Machines/Amiga/Amiga.hpp b/Machines/Amiga/Amiga.hpp
index 1faadc449..ff70320eb 100644
--- a/Machines/Amiga/Amiga.hpp
+++ b/Machines/Amiga/Amiga.hpp
@@ -19,7 +19,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Amiga.
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 };
 
 }
diff --git a/Machines/AmstradCPC/AmstradCPC.cpp b/Machines/AmstradCPC/AmstradCPC.cpp
index bf82561e7..b0b47e7c8 100644
--- a/Machines/AmstradCPC/AmstradCPC.cpp
+++ b/Machines/AmstradCPC/AmstradCPC.cpp
@@ -1391,14 +1391,14 @@ std::unique_ptr<Machine> machine(
 
 // See header; constructs and returns an instance of the Amstrad CPC.
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::AmstradCPC::Target;
-	const Target *const cpc_target = dynamic_cast<const Target *>(target);
-	if(cpc_target->catch_ssm_codes) {
-		return machine<true>(*cpc_target, rom_fetcher);
+	const auto &cpc_target = static_cast<const Target &>(target);
+	if(cpc_target.catch_ssm_codes) {
+		return machine<true>(cpc_target, rom_fetcher);
 	} else {
-		return machine<false>(*cpc_target, rom_fetcher);
+		return machine<false>(cpc_target, rom_fetcher);
 	}
 }
diff --git a/Machines/AmstradCPC/AmstradCPC.hpp b/Machines/AmstradCPC/AmstradCPC.hpp
index a7c5ec548..5a41c16e6 100644
--- a/Machines/AmstradCPC/AmstradCPC.hpp
+++ b/Machines/AmstradCPC/AmstradCPC.hpp
@@ -24,10 +24,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Amstrad CPC.
-	static std::unique_ptr<Machine> create(
-		const Analyser::Static::Target *target,
-		const ROMMachine::ROMFetcher &rom_fetcher
-	);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options available for an Amstrad CPC.
 	class Options:
diff --git a/Machines/Apple/AppleII/AppleII.cpp b/Machines/Apple/AppleII/AppleII.cpp
index 3ad62b24c..4a9b5b13c 100644
--- a/Machines/Apple/AppleII/AppleII.cpp
+++ b/Machines/Apple/AppleII/AppleII.cpp
@@ -1094,28 +1094,32 @@ public:
 
 using namespace Apple::II;
 
+namespace {
+template <bool has_mockingboard>
+std::unique_ptr<Machine> create(
+	const Analyser::Static::AppleII::Target &target,
+	const ROMMachine::ROMFetcher &fetcher
+) {
+	switch(target.model) {
+		default: return nullptr;
+		using enum Analyser::Static::AppleII::Target::Model;
+		case II:			return std::make_unique<ConcreteMachine<II, has_mockingboard>>(target, fetcher);
+		case IIplus:		return std::make_unique<ConcreteMachine<IIplus, has_mockingboard>>(target, fetcher);
+		case IIe:			return std::make_unique<ConcreteMachine<IIe, has_mockingboard>>(target, fetcher);
+		case EnhancedIIe:	return std::make_unique<ConcreteMachine<EnhancedIIe, has_mockingboard>>(target, fetcher);
+	}
+}
+}
+
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::AppleII::Target;
-	const Target *const appleii_target = dynamic_cast<const Target *>(target);
-
-	if(appleii_target->has_mockingboard) {
-		switch(appleii_target->model) {
-			default: return nullptr;
-			case Target::Model::II: return std::make_unique<ConcreteMachine<Target::Model::II, true>>(*appleii_target, rom_fetcher);
-			case Target::Model::IIplus: return std::make_unique<ConcreteMachine<Target::Model::IIplus, true>>(*appleii_target, rom_fetcher);
-			case Target::Model::IIe: return std::make_unique<ConcreteMachine<Target::Model::IIe, true>>(*appleii_target, rom_fetcher);
-			case Target::Model::EnhancedIIe: return std::make_unique<ConcreteMachine<Target::Model::EnhancedIIe, true>>(*appleii_target, rom_fetcher);
-		}
+	const auto &appleii_target = static_cast<const Target &>(target);
+	if(appleii_target.has_mockingboard) {
+		return ::create<true>(appleii_target, rom_fetcher);
 	} else {
-		switch(appleii_target->model) {
-			default: return nullptr;
-			case Target::Model::II: return std::make_unique<ConcreteMachine<Target::Model::II, false>>(*appleii_target, rom_fetcher);
-			case Target::Model::IIplus: return std::make_unique<ConcreteMachine<Target::Model::IIplus, false>>(*appleii_target, rom_fetcher);
-			case Target::Model::IIe: return std::make_unique<ConcreteMachine<Target::Model::IIe, false>>(*appleii_target, rom_fetcher);
-			case Target::Model::EnhancedIIe: return std::make_unique<ConcreteMachine<Target::Model::EnhancedIIe, false>>(*appleii_target, rom_fetcher);
-		}
+		return ::create<false>(appleii_target, rom_fetcher);
 	}
 }
diff --git a/Machines/Apple/AppleII/AppleII.hpp b/Machines/Apple/AppleII/AppleII.hpp
index 3264ae9f1..bc0c6e9b3 100644
--- a/Machines/Apple/AppleII/AppleII.hpp
+++ b/Machines/Apple/AppleII/AppleII.hpp
@@ -21,7 +21,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an AppleII.
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options available for an Apple II.
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {
diff --git a/Machines/Apple/AppleIIgs/AppleIIgs.cpp b/Machines/Apple/AppleIIgs/AppleIIgs.cpp
index 5164c00b7..d08386eac 100644
--- a/Machines/Apple/AppleIIgs/AppleIIgs.cpp
+++ b/Machines/Apple/AppleIIgs/AppleIIgs.cpp
@@ -1011,8 +1011,11 @@ private:
 using namespace Apple::IIgs;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	return std::make_unique<ConcreteMachine>(*dynamic_cast<const Analyser::Static::AppleIIgs::Target *>(target), rom_fetcher);
+	return std::make_unique<ConcreteMachine>(
+		static_cast<const Analyser::Static::AppleIIgs::Target &>(target),
+		rom_fetcher
+	);
 }
diff --git a/Machines/Apple/AppleIIgs/AppleIIgs.hpp b/Machines/Apple/AppleIIgs/AppleIIgs.hpp
index d8996c18f..346fd3c51 100644
--- a/Machines/Apple/AppleIIgs/AppleIIgs.hpp
+++ b/Machines/Apple/AppleIIgs/AppleIIgs.hpp
@@ -21,7 +21,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an AppleIIgs.
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 };
 
 }
diff --git a/Machines/Apple/Macintosh/Macintosh.cpp b/Machines/Apple/Macintosh/Macintosh.cpp
index 40f1ca6cc..300bbb8ff 100644
--- a/Machines/Apple/Macintosh/Macintosh.cpp
+++ b/Machines/Apple/Macintosh/Macintosh.cpp
@@ -843,17 +843,18 @@ private:
 using namespace Apple::Macintosh;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	auto *const mac_target = dynamic_cast<const Analyser::Static::Macintosh::Target *>(target);
+	const auto &mac_target = static_cast<const Analyser::Static::Macintosh::Target &>(target);
+
+	switch(mac_target.model) {
+		using enum Analyser::Static::Macintosh::Target::Model;
 
-	using Model = Analyser::Static::Macintosh::Target::Model;
-	switch(mac_target->model) {
 		default:
-		case Model::Mac128k:	return std::make_unique<ConcreteMachine<Model::Mac128k>>(*mac_target, rom_fetcher);
-		case Model::Mac512k:	return std::make_unique<ConcreteMachine<Model::Mac512k>>(*mac_target, rom_fetcher);
-		case Model::Mac512ke:	return std::make_unique<ConcreteMachine<Model::Mac512ke>>(*mac_target, rom_fetcher);
-		case Model::MacPlus:	return std::make_unique<ConcreteMachine<Model::MacPlus>>(*mac_target, rom_fetcher);
+		case Mac128k:	return std::make_unique<ConcreteMachine<Mac128k>>(mac_target, rom_fetcher);
+		case Mac512k:	return std::make_unique<ConcreteMachine<Mac512k>>(mac_target, rom_fetcher);
+		case Mac512ke:	return std::make_unique<ConcreteMachine<Mac512ke>>(mac_target, rom_fetcher);
+		case MacPlus:	return std::make_unique<ConcreteMachine<MacPlus>>(mac_target, rom_fetcher);
 	}
 }
diff --git a/Machines/Apple/Macintosh/Macintosh.hpp b/Machines/Apple/Macintosh/Macintosh.hpp
index 340af4e30..d01e0e56a 100644
--- a/Machines/Apple/Macintosh/Macintosh.hpp
+++ b/Machines/Apple/Macintosh/Macintosh.hpp
@@ -19,7 +19,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns a Macintosh.
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::QuickBoot<Options> {
 		friend Configurable::Options::QuickBoot<Options>;
diff --git a/Machines/Atari/2600/Atari2600.cpp b/Machines/Atari/2600/Atari2600.cpp
index 09eff7da4..301dea214 100644
--- a/Machines/Atari/2600/Atari2600.cpp
+++ b/Machines/Atari/2600/Atari2600.cpp
@@ -219,7 +219,7 @@ private:
 
 using namespace Atari2600;
 
-std::unique_ptr<Machine> Machine::create(const Analyser::Static::Target *const target, const ROMMachine::ROMFetcher &) {
-	const Target *const atari_target = dynamic_cast<const Target *>(target);
-	return std::make_unique<Atari2600::ConcreteMachine>(*atari_target);
+std::unique_ptr<Machine> Machine::create(const Analyser::Static::Target &target, const ROMMachine::ROMFetcher &) {
+	const auto &atari_target = static_cast<const Target &>(target);
+	return std::make_unique<Atari2600::ConcreteMachine>(atari_target);
 }
diff --git a/Machines/Atari/2600/Atari2600.hpp b/Machines/Atari/2600/Atari2600.hpp
index a7f66f224..cfb112fe3 100644
--- a/Machines/Atari/2600/Atari2600.hpp
+++ b/Machines/Atari/2600/Atari2600.hpp
@@ -25,7 +25,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Atari 2600 on the heap.
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	/// Sets the switch @c input to @c state.
 	virtual void set_switch_is_enabled(Atari2600Switch, bool) = 0;
diff --git a/Machines/Atari/ST/AtariST.cpp b/Machines/Atari/ST/AtariST.cpp
index c22ab8fc3..ff0895d94 100644
--- a/Machines/Atari/ST/AtariST.cpp
+++ b/Machines/Atari/ST/AtariST.cpp
@@ -709,13 +709,9 @@ private:
 using namespace Atari::ST;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	auto *const atari_target = dynamic_cast<const Analyser::Static::AtariST::Target *>(target);
-	if(!atari_target) {
-		return nullptr;
-	}
-
-	return std::make_unique<ConcreteMachine>(*atari_target, rom_fetcher);
+	const auto &atari_target = static_cast<const Analyser::Static::AtariST::Target &>(target);
+	return std::make_unique<ConcreteMachine>(atari_target, rom_fetcher);
 }
diff --git a/Machines/Atari/ST/AtariST.hpp b/Machines/Atari/ST/AtariST.hpp
index 0ce33f1ef..dfdefa6ce 100644
--- a/Machines/Atari/ST/AtariST.hpp
+++ b/Machines/Atari/ST/AtariST.hpp
@@ -20,7 +20,7 @@ namespace Atari::ST {
 struct Machine {
 	virtual ~Machine() = default;
 
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {
 		friend Configurable::Options::Display<Options>;
diff --git a/Machines/ColecoVision/ColecoVision.cpp b/Machines/ColecoVision/ColecoVision.cpp
index be57445b7..061ee91db 100644
--- a/Machines/ColecoVision/ColecoVision.cpp
+++ b/Machines/ColecoVision/ColecoVision.cpp
@@ -421,8 +421,8 @@ private:
 using namespace Coleco::Vision;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	return std::make_unique<ConcreteMachine>(*target, rom_fetcher);
+	return std::make_unique<ConcreteMachine>(target, rom_fetcher);
 }
diff --git a/Machines/ColecoVision/ColecoVision.hpp b/Machines/ColecoVision/ColecoVision.hpp
index a2ef85a42..5964a5231 100644
--- a/Machines/ColecoVision/ColecoVision.hpp
+++ b/Machines/ColecoVision/ColecoVision.hpp
@@ -19,7 +19,7 @@ namespace Coleco::Vision {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {
 		friend Configurable::Options::Display<Options>;
diff --git a/Machines/Commodore/Plus4/Plus4.cpp b/Machines/Commodore/Plus4/Plus4.cpp
index 5d59cf4b1..ce356adef 100644
--- a/Machines/Commodore/Plus4/Plus4.cpp
+++ b/Machines/Commodore/Plus4/Plus4.cpp
@@ -752,10 +752,10 @@ private:
 }
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::Commodore::Plus4Target;
-	const Target *const commodore_target = dynamic_cast<const Target *>(target);
-	return std::make_unique<ConcreteMachine>(*commodore_target, rom_fetcher);
+	const auto &commodore_target = static_cast<const Target &>(target);
+	return std::make_unique<ConcreteMachine>(commodore_target, rom_fetcher);
 }
diff --git a/Machines/Commodore/Plus4/Plus4.hpp b/Machines/Commodore/Plus4/Plus4.hpp
index 686f29ee0..16e0a65e9 100644
--- a/Machines/Commodore/Plus4/Plus4.hpp
+++ b/Machines/Commodore/Plus4/Plus4.hpp
@@ -22,7 +22,7 @@ std::unique_ptr<Reflection::Struct> get_options();
 struct Machine {
 	virtual ~Machine() = default;
 
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,
diff --git a/Machines/Commodore/Vic-20/Vic20.cpp b/Machines/Commodore/Vic-20/Vic20.cpp
index 05dc159f8..91b98a4f1 100644
--- a/Machines/Commodore/Vic-20/Vic20.cpp
+++ b/Machines/Commodore/Vic-20/Vic20.cpp
@@ -818,10 +818,10 @@ private:
 using namespace Commodore::Vic20;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::Commodore::Vic20Target;
-	const Target *const commodore_target = dynamic_cast<const Target *>(target);
-	return std::make_unique<Vic20::ConcreteMachine>(*commodore_target, rom_fetcher);
+	const auto &commodore_target = static_cast<const Target &>(target);
+	return std::make_unique<Vic20::ConcreteMachine>(commodore_target, rom_fetcher);
 }
diff --git a/Machines/Commodore/Vic-20/Vic20.hpp b/Machines/Commodore/Vic-20/Vic20.hpp
index 813d058ad..bfbd3702d 100644
--- a/Machines/Commodore/Vic-20/Vic20.hpp
+++ b/Machines/Commodore/Vic-20/Vic20.hpp
@@ -24,7 +24,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns a Vic-20.
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,
diff --git a/Machines/Enterprise/Enterprise.cpp b/Machines/Enterprise/Enterprise.cpp
index acb01a25a..dded89ea6 100644
--- a/Machines/Enterprise/Enterprise.cpp
+++ b/Machines/Enterprise/Enterprise.cpp
@@ -991,11 +991,11 @@ std::unique_ptr<Machine> machine(
 }
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::Enterprise::Target;
-	const Target &enterprise_target = *dynamic_cast<const Target *>(target);
+	const auto &enterprise_target = static_cast<const Target &>(target);
 
 	if(enterprise_target.dos != Target::DOS::None) {
 		return machine<true>(enterprise_target, rom_fetcher);
diff --git a/Machines/Enterprise/Enterprise.hpp b/Machines/Enterprise/Enterprise.hpp
index cfe487ca3..aeec779c2 100644
--- a/Machines/Enterprise/Enterprise.hpp
+++ b/Machines/Enterprise/Enterprise.hpp
@@ -25,7 +25,7 @@ namespace Enterprise {
 */
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options available for an Enterprise.
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {
diff --git a/Machines/MSX/MSX.cpp b/Machines/MSX/MSX.cpp
index 3901044ba..8bb688b83 100644
--- a/Machines/MSX/MSX.cpp
+++ b/Machines/MSX/MSX.cpp
@@ -1039,22 +1039,32 @@ private:
 
 using namespace MSX;
 
-std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+namespace {
+
+template <bool has_msx_music>
+std::unique_ptr<Machine> create(
+	const Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	const auto msx_target = dynamic_cast<const Target *>(target);
-	if(msx_target->has_msx_music) {
-		switch(msx_target->model) {
-			default:					return nullptr;
-			case Target::Model::MSX1:	return std::make_unique<ConcreteMachine<Target::Model::MSX1, true>>(*msx_target, rom_fetcher);
-			case Target::Model::MSX2:	return std::make_unique<ConcreteMachine<Target::Model::MSX2, true>>(*msx_target, rom_fetcher);
-		}
+	switch(target.model) {
+		using enum Target::Model;
+
+		default:	return nullptr;
+		case MSX1:	return std::make_unique<ConcreteMachine<MSX1, has_msx_music>>(target, rom_fetcher);
+		case MSX2:	return std::make_unique<ConcreteMachine<MSX2, has_msx_music>>(target, rom_fetcher);
+	}
+}
+
+}
+
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target &target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
+	const auto &msx_target = static_cast<const Target &>(target);
+	if(msx_target.has_msx_music) {
+		return ::create<true>(msx_target, rom_fetcher);
 	} else {
-		switch(msx_target->model) {
-			default:					return nullptr;
-			case Target::Model::MSX1:	return std::make_unique<ConcreteMachine<Target::Model::MSX1, false>>(*msx_target, rom_fetcher);
-			case Target::Model::MSX2:	return std::make_unique<ConcreteMachine<Target::Model::MSX2, false>>(*msx_target, rom_fetcher);
-		}
+		return ::create<false>(msx_target, rom_fetcher);
 	}
 }
diff --git a/Machines/MSX/MSX.hpp b/Machines/MSX/MSX.hpp
index fff6c4fee..54e789303 100644
--- a/Machines/MSX/MSX.hpp
+++ b/Machines/MSX/MSX.hpp
@@ -19,7 +19,7 @@ namespace MSX {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,
diff --git a/Machines/MasterSystem/MasterSystem.cpp b/Machines/MasterSystem/MasterSystem.cpp
index 315f4bde3..5747b83ee 100644
--- a/Machines/MasterSystem/MasterSystem.cpp
+++ b/Machines/MasterSystem/MasterSystem.cpp
@@ -607,21 +607,18 @@ private:
 using namespace Sega::MasterSystem;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::Sega::Target;
-	const Target *const sega_target = dynamic_cast<const Target *>(target);
+	const auto &sega_target = static_cast<const Target &>(target);
 
-	switch(sega_target->model) {
-		case Target::Model::SG1000:
-			return std::make_unique<ConcreteMachine<Target::Model::SG1000>>(*sega_target, rom_fetcher);
-		case Target::Model::MasterSystem:
-			return std::make_unique<ConcreteMachine<Target::Model::MasterSystem>>(*sega_target, rom_fetcher);
-		case Target::Model::MasterSystem2:
-			return std::make_unique<ConcreteMachine<Target::Model::MasterSystem2>>(*sega_target, rom_fetcher);
-		default:
-			assert(false);
-			return nullptr;
+	switch(sega_target.model) {
+		using enum Target::Model;
+
+		case SG1000:		return std::make_unique<ConcreteMachine<SG1000>>(sega_target, rom_fetcher);
+		case MasterSystem:	return std::make_unique<ConcreteMachine<MasterSystem>>(sega_target, rom_fetcher);
+		case MasterSystem2:	return std::make_unique<ConcreteMachine<MasterSystem2>>(sega_target, rom_fetcher);
+		default:			__builtin_unreachable();
 	}
 }
diff --git a/Machines/MasterSystem/MasterSystem.hpp b/Machines/MasterSystem/MasterSystem.hpp
index 6d5c90e44..59f284f36 100644
--- a/Machines/MasterSystem/MasterSystem.hpp
+++ b/Machines/MasterSystem/MasterSystem.hpp
@@ -19,7 +19,7 @@ namespace Sega::MasterSystem {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {
 		friend Configurable::Options::Display<Options>;
diff --git a/Machines/Oric/Oric.cpp b/Machines/Oric/Oric.cpp
index 53b42fdce..83fae44a0 100644
--- a/Machines/Oric/Oric.cpp
+++ b/Machines/Oric/Oric.cpp
@@ -836,14 +836,14 @@ std::unique_ptr<Machine> machine(const Analyser::Static::Oric::Target &target, c
 }
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target_hint,
+	const Analyser::Static::Target &target_hint,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	auto *const oric_target = dynamic_cast<const Analyser::Static::Oric::Target *>(target_hint);
+	const auto &oric_target = static_cast<const Analyser::Static::Oric::Target &>(target_hint);
 
-	switch(oric_target->processor) {
-		case Processor::WDC65816:	return machine<CPU::MOS6502Esque::Type::TWDC65816>(*oric_target, rom_fetcher);
-		case Processor::MOS6502:	return machine<CPU::MOS6502Esque::Type::T6502>(*oric_target, rom_fetcher);
+	switch(oric_target.processor) {
+		case Processor::WDC65816:	return machine<CPU::MOS6502Esque::Type::TWDC65816>(oric_target, rom_fetcher);
+		case Processor::MOS6502:	return machine<CPU::MOS6502Esque::Type::T6502>(oric_target, rom_fetcher);
 	}
 
 	return nullptr;
diff --git a/Machines/Oric/Oric.hpp b/Machines/Oric/Oric.hpp
index 9c3e926a4..6c52d24bb 100644
--- a/Machines/Oric/Oric.hpp
+++ b/Machines/Oric/Oric.hpp
@@ -22,7 +22,7 @@ namespace Oric {
 */
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,
diff --git a/Machines/PCCompatible/PCCompatible.cpp b/Machines/PCCompatible/PCCompatible.cpp
index fb11df1a2..0440d7b27 100644
--- a/Machines/PCCompatible/PCCompatible.cpp
+++ b/Machines/PCCompatible/PCCompatible.cpp
@@ -1154,14 +1154,14 @@ std::unique_ptr<Machine> machine(const Target &target, const ROMMachine::ROMFetc
 }
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	const Target *const pc_target = dynamic_cast<const Target *>(target);
+	const auto &pc_target = static_cast<const Target &>(target);
 	using VideoAdaptor = Target::VideoAdaptor;
-	switch(pc_target->adaptor) {
-		case VideoAdaptor::MDA:	return machine<VideoAdaptor::MDA>(*pc_target, rom_fetcher);
-		case VideoAdaptor::CGA:	return machine<VideoAdaptor::CGA>(*pc_target, rom_fetcher);
+	switch(pc_target.adaptor) {
+		case VideoAdaptor::MDA:	return machine<VideoAdaptor::MDA>(pc_target, rom_fetcher);
+		case VideoAdaptor::CGA:	return machine<VideoAdaptor::CGA>(pc_target, rom_fetcher);
 		default: return nullptr;
 	}
 }
diff --git a/Machines/PCCompatible/PCCompatible.hpp b/Machines/PCCompatible/PCCompatible.hpp
index 7ae2effed..324a57ef7 100644
--- a/Machines/PCCompatible/PCCompatible.hpp
+++ b/Machines/PCCompatible/PCCompatible.hpp
@@ -22,7 +22,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns a PC Compatible.
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options [sometimes] available for a PC.
 	class Options:
diff --git a/Machines/Sinclair/ZX8081/ZX8081.cpp b/Machines/Sinclair/ZX8081/ZX8081.cpp
index 639818185..2efe6b713 100644
--- a/Machines/Sinclair/ZX8081/ZX8081.cpp
+++ b/Machines/Sinclair/ZX8081/ZX8081.cpp
@@ -499,12 +499,12 @@ using namespace Sinclair::ZX8081;
 
 // See header; constructs and returns an instance of the ZX80 or 81.
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	const auto zx_target = dynamic_cast<const Analyser::Static::ZX8081::Target *>(target);
+	const auto &zx_target = static_cast<const Analyser::Static::ZX8081::Target &>(target);
 
 	// Instantiate the correct type of machine.
-	if(zx_target->is_ZX81)	return std::make_unique<ConcreteMachine<true>>(*zx_target, rom_fetcher);
-	else					return std::make_unique<ConcreteMachine<false>>(*zx_target, rom_fetcher);
+	if(zx_target.is_ZX81)	return std::make_unique<ConcreteMachine<true>>(zx_target, rom_fetcher);
+	else					return std::make_unique<ConcreteMachine<false>>(zx_target, rom_fetcher);
 }
diff --git a/Machines/Sinclair/ZX8081/ZX8081.hpp b/Machines/Sinclair/ZX8081/ZX8081.hpp
index d02b5475e..7986ea72b 100644
--- a/Machines/Sinclair/ZX8081/ZX8081.hpp
+++ b/Machines/Sinclair/ZX8081/ZX8081.hpp
@@ -20,7 +20,7 @@ namespace Sinclair::ZX8081 {
 /// The ZX80/81 machine.
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	virtual void set_tape_is_playing(bool is_playing) = 0;
 	virtual bool get_tape_is_playing() = 0;
diff --git a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp
index 8446d668d..449cdd09d 100644
--- a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp
+++ b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp
@@ -1014,18 +1014,20 @@ private:
 using namespace Sinclair::ZXSpectrum;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	const auto zx_target = dynamic_cast<const Analyser::Static::ZXSpectrum::Target *>(target);
+	const auto &zx_target = static_cast<const Analyser::Static::ZXSpectrum::Target &>(target);
 
-	switch(zx_target->model) {
-		case Model::SixteenK:		return std::make_unique<ConcreteMachine<Model::SixteenK>>(*zx_target, rom_fetcher);
-		case Model::FortyEightK:	return std::make_unique<ConcreteMachine<Model::FortyEightK>>(*zx_target, rom_fetcher);
-		case Model::OneTwoEightK:	return std::make_unique<ConcreteMachine<Model::OneTwoEightK>>(*zx_target, rom_fetcher);
-		case Model::Plus2:			return std::make_unique<ConcreteMachine<Model::Plus2>>(*zx_target, rom_fetcher);
-		case Model::Plus2a:			return std::make_unique<ConcreteMachine<Model::Plus2a>>(*zx_target, rom_fetcher);
-		case Model::Plus3:			return std::make_unique<ConcreteMachine<Model::Plus3>>(*zx_target, rom_fetcher);
+	switch(zx_target.model) {
+		using enum Model;
+
+		case SixteenK:		return std::make_unique<ConcreteMachine<SixteenK>>(zx_target, rom_fetcher);
+		case FortyEightK:	return std::make_unique<ConcreteMachine<FortyEightK>>(zx_target, rom_fetcher);
+		case OneTwoEightK:	return std::make_unique<ConcreteMachine<OneTwoEightK>>(zx_target, rom_fetcher);
+		case Plus2:			return std::make_unique<ConcreteMachine<Plus2>>(zx_target, rom_fetcher);
+		case Plus2a:		return std::make_unique<ConcreteMachine<Plus2a>>(zx_target, rom_fetcher);
+		case Plus3:			return std::make_unique<ConcreteMachine<Plus3>>(zx_target, rom_fetcher);
 	}
 
 	return nullptr;
diff --git a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp
index 88b4928df..99048b83f 100644
--- a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp
+++ b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp
@@ -19,7 +19,7 @@ namespace Sinclair::ZXSpectrum {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	virtual void set_tape_is_playing(bool is_playing) = 0;
 	virtual bool get_tape_is_playing() = 0;
diff --git a/Machines/Tandy/CoCo/CoCo.cpp b/Machines/Tandy/CoCo/CoCo.cpp
index aa5fde351..b0bebfb99 100644
--- a/Machines/Tandy/CoCo/CoCo.cpp
+++ b/Machines/Tandy/CoCo/CoCo.cpp
@@ -11,7 +11,7 @@
 using namespace Tandy::CoCo;
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const ,
+	const Analyser::Static::Target &,
 	const ROMMachine::ROMFetcher &
 ) {
 	return nullptr;
diff --git a/Machines/Tandy/CoCo/CoCo.hpp b/Machines/Tandy/CoCo/CoCo.hpp
index 84573d888..39128a750 100644
--- a/Machines/Tandy/CoCo/CoCo.hpp
+++ b/Machines/Tandy/CoCo/CoCo.hpp
@@ -15,7 +15,7 @@ namespace Tandy::CoCo {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 };
 
 }
diff --git a/Machines/Thomson/MO/MO.cpp b/Machines/Thomson/MO/MO.cpp
index 851fae6e9..8312ba710 100644
--- a/Machines/Thomson/MO/MO.cpp
+++ b/Machines/Thomson/MO/MO.cpp
@@ -739,13 +739,13 @@ std::unique_ptr<Machine> machine(const Target &target, const ROMMachine::ROMFetc
 }
 
 std::unique_ptr<Machine> Machine::create(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
-	const Target *const thomson_target = dynamic_cast<const Target *>(target);
-	if(Analyser::Static::Thomson::is_mo6(thomson_target->model)) {
-		return machine<true>(*thomson_target, rom_fetcher);
+	const auto &thomson_target = static_cast<const Target &>(target);
+	if(Analyser::Static::Thomson::is_mo6(thomson_target.model)) {
+		return machine<true>(thomson_target, rom_fetcher);
 	} else {
-		return machine<false>(*thomson_target, rom_fetcher);
+		return machine<false>(thomson_target, rom_fetcher);
 	}
 }
diff --git a/Machines/Thomson/MO/MO.hpp b/Machines/Thomson/MO/MO.hpp
index 6e1baac96..2278bb96f 100644
--- a/Machines/Thomson/MO/MO.hpp
+++ b/Machines/Thomson/MO/MO.hpp
@@ -20,7 +20,7 @@ namespace Thomson::MO {
 struct Machine {
 	virtual ~Machine() = default;
 
-	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target &, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,
diff --git a/Machines/Utility/MachineForTarget.cpp b/Machines/Utility/MachineForTarget.cpp
index dbcc185b6..2613866e1 100644
--- a/Machines/Utility/MachineForTarget.cpp
+++ b/Machines/Utility/MachineForTarget.cpp
@@ -59,18 +59,18 @@
 namespace {
 struct MachineGenerator {
 	MachineGenerator(
-		const Analyser::Static::Target *const target,
+		const Analyser::Static::Target &target,
 		const ROMMachine::ROMFetcher &rom_fetcher
 	) : target(target), rom_fetcher(rom_fetcher) {}
 
-	const Analyser::Static::Target *const target;
+	const Analyser::Static::Target &target;
 	const ROMMachine::ROMFetcher &rom_fetcher;
 
 	std::unique_ptr<Machine::DynamicMachine> machine;
 
 	template <typename MachineT>
 	void posit(const Analyser::Machine name) {
-		if(target->machine == name) {
+		if(target.machine == name) {
 			machine = std::make_unique<Machine::TypedDynamicMachine<MachineT>>(MachineT::create(target, rom_fetcher));
 		}
 	}
@@ -78,7 +78,7 @@ struct MachineGenerator {
 }
 
 std::unique_ptr<Machine::DynamicMachine> Machine::MachineForTarget(
-	const Analyser::Static::Target *const target,
+	const Analyser::Static::Target &target,
 	const ROMMachine::ROMFetcher &rom_fetcher,
 	Machine::Error &error
 ) {
@@ -142,7 +142,7 @@ std::unique_ptr<Machine::DynamicMachine> Machine::MachineForTargets(
 	if(targets.size() > 1) {
 		std::vector<std::unique_ptr<Machine::DynamicMachine>> machines;
 		for(const auto &target: targets) {
-			machines.emplace_back(MachineForTarget(target.get(), rom_fetcher, error));
+			machines.emplace_back(MachineForTarget(*target, rom_fetcher, error));
 
 			// Exit early if any errors have occurred.
 			if(error != Error::None) {
@@ -160,7 +160,7 @@ std::unique_ptr<Machine::DynamicMachine> Machine::MachineForTargets(
 	}
 
 	// There's definitely exactly one target.
-	return MachineForTarget(targets.front().get(), rom_fetcher, error);
+	return MachineForTarget(*targets.front(), rom_fetcher, error);
 }
 
 std::string Machine::ShortNameForTargetMachine(const Analyser::Machine machine) {
diff --git a/Machines/Utility/MachineForTarget.hpp b/Machines/Utility/MachineForTarget.hpp
index 835f3ba62..c2336f3a1 100644
--- a/Machines/Utility/MachineForTarget.hpp
+++ b/Machines/Utility/MachineForTarget.hpp
@@ -54,7 +54,7 @@ std::unique_ptr<DynamicMachine> MachineForTargets(
 	by @c target. It is the caller's responsibility to delete the class when finished.
 */
 std::unique_ptr<DynamicMachine> MachineForTarget(
-	const Analyser::Static::Target *,
+	const Analyser::Static::Target &,
 	const ROMMachine::ROMFetcher &,
 	Machine::Error &);