diff --git a/Emulator/Base/CoreComponentTypes.h b/Emulator/Base/CoreComponentTypes.h
index e79ed4c13..77c8fc9eb 100644
--- a/Emulator/Base/CoreComponentTypes.h
+++ b/Emulator/Base/CoreComponentTypes.h
@@ -54,6 +54,9 @@ enum_long(OPT)
     OPT_CPU_OVERCLOCKING,
     OPT_CPU_RESET_VAL,
 
+    // FPU
+    OPT_FPU_REVISION,
+
     // Real-time clock
     OPT_RTC_MODEL,
 
@@ -187,6 +190,8 @@ struct OptionEnum : util::Reflection<OptionEnum, Option>
             case OPT_CPU_RESET_VAL:         return "CPU_RESET_VAL";
             case OPT_CPU_DASM_SYNTAX:       return "CPU_DASM_SYNTAX";
 
+            case OPT_FPU_REVISION:          return "FPU_REVISION";
+
             case OPT_RTC_MODEL:             return "RTC_MODEL";
 
             case OPT_CHIP_RAM:              return "CHIP_RAM";
diff --git a/Emulator/Base/Defaults.cpp b/Emulator/Base/Defaults.cpp
index 1faf43d42..6d80469fc 100644
--- a/Emulator/Base/Defaults.cpp
+++ b/Emulator/Base/Defaults.cpp
@@ -69,6 +69,7 @@ Defaults::Defaults()
     setFallback(OPT_CPU_DASM_SYNTAX, DASM_SYNTAX_MOIRA);
     setFallback(OPT_CPU_OVERCLOCKING, 0);
     setFallback(OPT_CPU_RESET_VAL, 0);
+    setFallback(OPT_FPU_REVISION, FPU_INTERNAL);
     setFallback(OPT_RTC_MODEL, RTC_OKI);
     setFallback(OPT_CHIP_RAM, 512);
     setFallback(OPT_SLOW_RAM, 512);
diff --git a/Emulator/Base/Thread.cpp b/Emulator/Base/Thread.cpp
index 106dc47ee..12337cf4f 100644
--- a/Emulator/Base/Thread.cpp
+++ b/Emulator/Base/Thread.cpp
@@ -58,7 +58,7 @@ Thread::execute<THREAD_ADAPTIVE>()
     }
 
     // Compute all missing frames
-    for (isize i = 0; i < missing; i++) execute();
+    for (isize i = 0; i < missing && isRunning(); i++) execute();
 
     loadClock.stop();
 }
diff --git a/Emulator/Components/Amiga.cpp b/Emulator/Components/Amiga.cpp
index f617c5e88..cd937f7a1 100644
--- a/Emulator/Components/Amiga.cpp
+++ b/Emulator/Components/Amiga.cpp
@@ -296,6 +296,7 @@ Amiga::getConfigItem(Option option) const
         case OPT_CPU_DASM_SYNTAX:
         case OPT_CPU_OVERCLOCKING:
         case OPT_CPU_RESET_VAL:
+        case OPT_FPU_REVISION:
 
             return cpu.getConfigItem(option);
             
@@ -562,7 +563,8 @@ Amiga::configure(Option option, i64 value)
         case OPT_CPU_OVERCLOCKING:
         case OPT_CPU_RESET_VAL:
         case OPT_CPU_DASM_SYNTAX:
-            
+        case OPT_FPU_REVISION:
+
             cpu.setConfigItem(option, value);
             break;
             
@@ -830,6 +832,7 @@ Amiga::configure(ConfigScheme scheme)
             case CONFIG_A1000_OCS_1MB:
 
                 configure(OPT_CPU_REVISION, CPU_68000);
+                configure(OPT_FPU_REVISION, FPU_INTERNAL);
                 configure(OPT_AGNUS_REVISION, AGNUS_OCS_OLD);
                 configure(OPT_DENISE_REVISION, DENISE_OCS);
                 configure(OPT_VIDEO_FORMAT, PAL);
@@ -840,6 +843,7 @@ Amiga::configure(ConfigScheme scheme)
             case CONFIG_A500_OCS_1MB:
                 
                 configure(OPT_CPU_REVISION, CPU_68000);
+                configure(OPT_FPU_REVISION, FPU_INTERNAL);
                 configure(OPT_AGNUS_REVISION, AGNUS_OCS);
                 configure(OPT_DENISE_REVISION, DENISE_OCS);
                 configure(OPT_VIDEO_FORMAT, PAL);
@@ -850,6 +854,7 @@ Amiga::configure(ConfigScheme scheme)
             case CONFIG_A500_ECS_1MB:
                 
                 configure(OPT_CPU_REVISION, CPU_68000);
+                configure(OPT_FPU_REVISION, FPU_INTERNAL);
                 configure(OPT_AGNUS_REVISION, AGNUS_ECS_1MB);
                 configure(OPT_DENISE_REVISION, DENISE_OCS);
                 configure(OPT_VIDEO_FORMAT, PAL);
@@ -860,13 +865,14 @@ Amiga::configure(ConfigScheme scheme)
             case CONFIG_A500_PLUS_1MB:
 
                 configure(OPT_CPU_REVISION, CPU_68000);
+                configure(OPT_FPU_REVISION, FPU_INTERNAL);
                 configure(OPT_AGNUS_REVISION, AGNUS_ECS_2MB);
                 configure(OPT_DENISE_REVISION, DENISE_ECS);
                 configure(OPT_VIDEO_FORMAT, PAL);
                 configure(OPT_CHIP_RAM, 512);
                 configure(OPT_SLOW_RAM, 512);
                 break;
-
+                
             default:
                 fatalError;
         }
diff --git a/Emulator/Components/Amiga.h b/Emulator/Components/Amiga.h
index b0ff4ca45..5bbec09c1 100644
--- a/Emulator/Components/Amiga.h
+++ b/Emulator/Components/Amiga.h
@@ -288,7 +288,9 @@ class Amiga : public Thread {
     // Reverts to factory settings
     void revertToFactorySettings();
 
-    
+    // Returns whether experimental FPU support should be enabled
+    bool fpuSupport() { return FPU_SUPPORT; }
+
 private:
     
     // Overrides a config option if the corresponding debug option is enabled
diff --git a/Emulator/Components/AmigaTypes.h b/Emulator/Components/AmigaTypes.h
index 975e1d676..6f7add977 100644
--- a/Emulator/Components/AmigaTypes.h
+++ b/Emulator/Components/AmigaTypes.h
@@ -125,7 +125,6 @@ struct ConfigSchemeEnum : util::Reflection<ConfigSchemeEnum, ConfigScheme>
             case CONFIG_A1000_OCS_1MB:  return "A1000_OCS_1MB";
             case CONFIG_A500_OCS_1MB:   return "A500_OCS_1MB";
             case CONFIG_A500_ECS_1MB:   return "A500_ECS_1MB";
-            case CONFIG_A500_PLUS_1MB:  return "A500_PLUS_1MB";
         }
         return "???";
     }
diff --git a/Emulator/Components/CPU/CPU.cpp b/Emulator/Components/CPU/CPU.cpp
index 0c2b08649..1a5cd2ee5 100644
--- a/Emulator/Components/CPU/CPU.cpp
+++ b/Emulator/Components/CPU/CPU.cpp
@@ -14,13 +14,11 @@
 #include "IOUtils.h"
 #include "Memory.h"
 #include "MsgQueue.h"
-#include "softfloat.h"
 
 //
 // Moira
 //
 
-
 namespace vamiga::moira {
 
 void
@@ -141,7 +139,13 @@ Moira::willExecute(const char *func, Instr I, Mode M, Size S, u16 opcode)
             break;
 
         default:
+        {
+            
+            char str[128];
+            disassemble(str, reg.pc0);
+            printf("%s\n", str);
             break;
+        }
     }
 }
 
@@ -288,6 +292,8 @@ CPU::getConfigItem(Option option) const
         case OPT_CPU_OVERCLOCKING:  return (long)config.overclocking;
         case OPT_CPU_RESET_VAL:     return (long)config.regResetVal;
 
+        case OPT_FPU_REVISION:      return (long)config.fpuRevision;
+
         default:
             fatalError;
     }
@@ -297,6 +303,7 @@ void
 CPU::setConfigItem(Option option, i64 value)
 {
     auto cpuModel = [&](CPURevision rev) { return moira::Model(rev); };
+    auto fpuModel = [&](FPURevision rev) { return moira::FPUModel(rev); };
     auto dasmModel = [&](DasmRevision rev) { return moira::Model(rev); };
     auto syntax = [&](DasmSyntax rev) { return moira::DasmSyntax(rev); };
 
@@ -314,6 +321,22 @@ CPU::setConfigItem(Option option, i64 value)
             resume();
             return;
 
+        case OPT_FPU_REVISION:
+
+            if (!amiga.fpuSupport()) {
+                throw VAError(ERROR_OPT_UNSUPPORTED);
+            }
+
+            if (!FPURevisionEnum::isValid(value)) {
+                throw VAError(ERROR_OPT_INVARG, FPURevisionEnum::keyList());
+            }
+
+            suspend();
+            config.fpuRevision = FPURevision(value);
+            cpu.setFpuModel(fpuModel(config.fpuRevision));
+            resume();
+            return;
+
         case OPT_CPU_DASM_REVISION:
 
             if (!DasmRevisionEnum::isValid(value)) {
@@ -365,8 +388,12 @@ CPU::resetConfig()
     std::vector <Option> options = {
 
         OPT_CPU_REVISION,
+        OPT_CPU_DASM_REVISION,
+        OPT_CPU_DASM_SYNTAX,
         OPT_CPU_OVERCLOCKING,
-        OPT_CPU_RESET_VAL
+        OPT_CPU_RESET_VAL,
+        
+        OPT_FPU_REVISION
     };
 
     for (auto &option : options) {
@@ -460,8 +487,13 @@ CPU::_dump(Category category, std::ostream& os) const
 
     if (category == Category::Config) {
 
+        string fputxt =
+        config.fpuRevision == FPU_INTERNAL ? " (none)" : " (external coprocessor)";
+        
         os << util::tab("CPU revision");
         os << CPURevisionEnum::key(config.revision) << std::endl;
+        os << util::tab("FPU revision");
+        os << FPURevisionEnum::key(config.fpuRevision) << fputxt << std::endl;
         os << util::tab("DASM revision");
         os << DasmRevisionEnum::key(config.dasmRevision) << std::endl;
         os << util::tab("DASM syntax");
@@ -547,22 +579,39 @@ CPU::_dump(Category category, std::ostream& os) const
     }
 
     if (category == Category::Fpu) {
-        
-        os << util::tab("FPIAR");
-        os << util::hex(fpu.fpiar) << std::endl;
-        os << util::tab("FPSR");
-        os << util::hex(fpu.fpsr) << std::endl;
+                
         os << util::tab("FPCR");
         os << util::hex(fpu.fpcr) << std::endl;
-
-        /*
-         for (isize i = 0; i < 8; i++) {
-
-         auto value = softfloat::floatx80_to_float32(fpu.fpr[i].raw);
-         os << util::tab("FP" + std::to_string(i));
-         os << util::hex(u32(value)) << std::endl;
-         }
-         */
+        os << util::tab("FPSR");
+        os << util::hex(fpu.fpsr) << std::endl;
+        os << util::tab("FPIAR");
+        os << util::hex(fpu.fpiar) << std::endl;
+        os << std::endl;
+        
+        os << util::tab("Rounding mode");
+        switch (fpu.getRoundingMode()) {
+            case moira::FPU_RND_NEAREST:    os << "NEAREST"; break;
+            case moira::FPU_RND_ZERO:       os << "ZERO"; break;
+            case moira::FPU_RND_DOWNWARD:   os << "DOWNWARD"; break;
+            case moira::FPU_RND_UPWARD:     os << "UPDWARD"; break;
+        }
+        os << std::endl;
+        os << util::tab("Precision");
+        switch (fpu.getPrecision()) {
+            case moira::FPU_PREC_EXTENDED:  os << "EXTENDED"; break;
+            case moira::FPU_PREC_SINGLE:    os << "SINGLE"; break;
+            case moira::FPU_PREC_DOUBLE:    os << "DOUBLE"; break;
+            case moira::FPU_PREC_UNDEFINED: os << "UNDEFINED"; break;
+        }
+        os << std::endl << std::endl;
+        
+        for (isize i = 0; i < 8; i++) {
+            
+            os << util::tab("FP" + std::to_string(i));
+            // os << fpu.fpr[i] << std::endl;
+            os << util::hex(fpu.fpr[i].val.raw.high) << ":";
+            os << util::hex(fpu.fpr[i].val.raw.low) << std::endl;
+        }
     }
     
     if (category == Category::Breakpoints) {
@@ -638,6 +687,7 @@ CPU::_trackOff()
     debugger.disableLogging();
 }
 
+/*
 isize
 CPU::_load(const u8 *buffer)
 {
@@ -653,10 +703,19 @@ CPU::_load(const u8 *buffer)
 
     return isize(reader.ptr - buffer);
 }
+*/
 
 isize
 CPU::didLoadFromBuffer(const u8 *buffer)
 {
+    auto cpuModel = (moira::Model)config.revision;
+    auto fpuModel = (moira::FPUModel)config.fpuRevision;
+    auto dasmModel = (moira::Model)config.dasmRevision;
+
+    // Rectify the CPU and FPU type
+    setModel(cpuModel, dasmModel);
+    fpu.setModel(fpuModel);
+
     /* Because we don't save breakpoints and watchpoints in a snapshot, the
      * CPU flags for checking breakpoints and watchpoints can be in a corrupt
      * state after loading. These flags need to be updated according to the
@@ -741,7 +800,7 @@ CPU::disassembleWords(u32 addr, isize len)
 {
     static char result[64];
 
-    dump16(result, addr, len);
+    dump16(result, addr, (int)len);
     return result;
 }
 
diff --git a/Emulator/Components/CPU/CPU.h b/Emulator/Components/CPU/CPU.h
index 86e66b9af..c80fad926 100644
--- a/Emulator/Components/CPU/CPU.h
+++ b/Emulator/Components/CPU/CPU.h
@@ -76,6 +76,7 @@ class CPU : public moira::Moira {
         worker
 
         << config.revision
+        << config.fpuRevision
         << config.dasmRevision
         << config.overclocking
         << config.regResetVal;
@@ -128,13 +129,34 @@ class CPU : public moira::Moira {
             << loopModeDelay
             << readBuffer
             << writeBuffer
-            << flags;
+            << flags
+            
+            // << fpu.model
+            << fpu.fpr[0].val.raw.high
+            << fpu.fpr[0].val.raw.low
+            << fpu.fpr[1].val.raw.high
+            << fpu.fpr[1].val.raw.low
+            << fpu.fpr[2].val.raw.high
+            << fpu.fpr[2].val.raw.low
+            << fpu.fpr[3].val.raw.high
+            << fpu.fpr[3].val.raw.low
+            << fpu.fpr[4].val.raw.high
+            << fpu.fpr[4].val.raw.low
+            << fpu.fpr[5].val.raw.high
+            << fpu.fpr[5].val.raw.low
+            << fpu.fpr[6].val.raw.high
+            << fpu.fpr[6].val.raw.low
+            << fpu.fpr[7].val.raw.high
+            << fpu.fpr[7].val.raw.low
+            << fpu.fpcr
+            << fpu.fpsr
+            << fpu.fpiar;
         }
     }
 
     isize _size() override { COMPUTE_SNAPSHOT_SIZE }
     u64 _checksum() override { COMPUTE_SNAPSHOT_CHECKSUM }
-    isize _load(const u8 *buffer) override;
+    isize _load(const u8 *buffer) override { LOAD_SNAPSHOT_ITEMS }
     isize _save(u8 *buffer) override { SAVE_SNAPSHOT_ITEMS }
     isize didLoadFromBuffer(const u8 *buffer) override;
     
diff --git a/Emulator/Components/CPU/CPUTypes.h b/Emulator/Components/CPU/CPUTypes.h
index 014f36103..cf1a47daf 100644
--- a/Emulator/Components/CPU/CPUTypes.h
+++ b/Emulator/Components/CPU/CPUTypes.h
@@ -52,6 +52,35 @@ struct CPURevisionEnum : util::Reflection<CPURevisionEnum, CPURevision>
 };
 #endif
 
+enum_long(FPU_REVISION)
+{
+    FPU_INTERNAL,
+    FPU_68881,
+    FPU_68882
+};
+typedef FPU_REVISION FPURevision;
+
+#ifdef __cplusplus
+struct FPURevisionEnum : util::Reflection<FPURevisionEnum, FPURevision>
+{
+    static constexpr long minVal = 0;
+    static constexpr long maxVal = FPU_68882;
+    static bool isValid(auto val) { return val >= minVal && val <= maxVal; }
+
+    static const char *prefix() { return "FPU"; }
+    static const char *key(CPURevision value)
+    {
+        switch (value) {
+
+            case FPU_INTERNAL:  return "INTERNAL";
+            case FPU_68881:     return "68881";
+            case FPU_68882:     return "68882";
+        }
+        return "???";
+    }
+};
+#endif
+
 enum_long(DASM_REVISION)
 {
     DASM_68000,
@@ -134,6 +163,7 @@ struct DasmSyntaxEnum : util::Reflection<DasmSyntaxEnum, DasmSyntax>
 typedef struct
 {
     CPURevision revision;
+    FPURevision fpuRevision;
     DasmRevision dasmRevision;
     DasmSyntax dasmSyntax;
     isize overclocking;
diff --git a/Emulator/Components/CPU/Moira/CMakeLists.txt b/Emulator/Components/CPU/Moira/CMakeLists.txt
index 54a11ed12..4ede3a71f 100644
--- a/Emulator/Components/CPU/Moira/CMakeLists.txt
+++ b/Emulator/Components/CPU/Moira/CMakeLists.txt
@@ -3,5 +3,7 @@ target_include_directories(vAmigaCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_sources(vAmigaCore PRIVATE
 
 Moira.cpp
+MoiraFPU.cpp
 MoiraDebugger.cpp
+FpuFormats.cpp
 )
diff --git a/Emulator/Components/CPU/Moira/FpuFormats.cpp b/Emulator/Components/CPU/Moira/FpuFormats.cpp
new file mode 100644
index 000000000..a46d788e1
--- /dev/null
+++ b/Emulator/Components/CPU/Moira/FpuFormats.cpp
@@ -0,0 +1,740 @@
+// -----------------------------------------------------------------------------
+// This file is part of Moira - A Motorola 68k emulator
+//
+// Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
+// Published under the terms of the MIT License
+// -----------------------------------------------------------------------------
+
+#include "config.h"
+#include "FpuFormats.h"
+#include "MoiraFPU.h"
+#include <sstream>
+#include <cmath>
+
+namespace vamiga::moira {
+
+//
+// FpuByte
+//
+
+FpuByte::FpuByte(const FpuExtended &value, ExcHandler handler)
+{
+    softfloat::float_exception_flags = 0;
+    auto converted = softfloat::floatx80_to_int32(value.raw);
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        handler(FPEXP_INEX2);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        handler(FPEXP_OVFL);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        handler(FPEXP_UNFL);
+    }
+    if (converted > 0x7F) {
+        handler(FPEXP_OPERR); converted = 0x7F;
+    }
+    if (converted < -0x80) {
+        handler(FPEXP_OPERR); converted = -0x80;
+    }
+    
+    raw = i8(converted);
+}
+
+FpuByte::FpuByte(const FPUReg &reg, ExcHandler handler) : FpuByte(reg.val, handler) { }
+
+
+//
+// FpuWord
+//
+
+FpuWord::FpuWord(const FpuExtended &value, ExcHandler handler)
+{
+    softfloat::float_exception_flags = 0;
+    auto converted = softfloat::floatx80_to_int32(value.raw);
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        handler(FPEXP_INEX2);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        handler(FPEXP_OVFL);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        handler(FPEXP_UNFL);
+    }
+    if (converted > 0x7FFF) {
+        handler(FPEXP_OPERR); converted = 0x7FFF;
+    }
+    if (converted < -0x8000) {
+        handler(FPEXP_OPERR); converted = -0x8000;
+    }
+
+    raw = i16(converted);
+}
+
+FpuWord::FpuWord(const FPUReg &reg, ExcHandler handler) : FpuWord(reg.val, handler) { }
+
+
+//
+// FpuLong
+//
+
+FpuLong::FpuLong(const FpuExtended &value, ExcHandler handler)
+{
+    softfloat::float_exception_flags = 0;
+    raw = u32(softfloat::floatx80_to_int32(value.raw));
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        handler(FPEXP_INEX2);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        handler(FPEXP_OVFL);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        handler(FPEXP_UNFL);
+    }
+}
+
+FpuLong::FpuLong(const FPUReg &reg, ExcHandler handler) : FpuLong(reg.val, handler) { }
+
+
+//
+// FpuSingle
+//
+
+FpuSingle::FpuSingle(const class FpuExtended &value, ExcHandler handler)
+{
+    u32 flags = 0;
+
+    long double ldv = value.asLongDouble();
+
+    if (ldv > std::numeric_limits<float>::max()) {
+
+        float posinf = std::copysign(std::numeric_limits<float>::infinity(), 1.0f);
+        flags |= FPEXP_OVFL | FPEXP_INEX2;
+        raw = *((u32 *)&posinf);
+
+    } else if (ldv < std::numeric_limits<float>::lowest()) {
+
+        float neginf = std::copysign(std::numeric_limits<float>::infinity(), -1.0f);
+        flags |= FPEXP_OVFL | FPEXP_INEX2;
+        raw = *((u32 *)&neginf);
+
+    } else {
+
+        softfloat::float_exception_flags = 0;
+        raw = floatx80_to_float32(value.raw);
+
+        if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+            flags |= FPEXP_INEX2;
+        }
+        if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+            flags |= FPEXP_OVFL;
+        }
+        if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+            flags |= FPEXP_UNFL;
+        }
+    }
+    handler(flags);
+}
+
+FpuSingle::FpuSingle(const class FpuExtended &value, FpuRoundingMode mode, ExcHandler handler)
+{
+    const float maxflt = std::numeric_limits<float>::max();
+    const float minflt = std::numeric_limits<float>::lowest();
+    const float posinf = std::copysign(std::numeric_limits<float>::infinity(), 1.0f);
+    const float neginf = std::copysign(std::numeric_limits<float>::infinity(), -1.0f);
+
+    u32 flags = 0;
+
+    long double ldv = value.asLongDouble();
+
+    if (ldv > maxflt) {
+
+        if (mode == FPU_RND_ZERO || mode == FPU_RND_DOWNWARD) {
+
+            flags |= FPEXP_OVFL | FPEXP_INEX2;
+            raw = *((u32 *)&maxflt);
+
+        } else {
+
+            flags |= FPEXP_OVFL | FPEXP_INEX2;
+            raw = *((u32 *)&posinf);
+        }
+
+    } else if (ldv < minflt) {
+
+        if (mode == FPU_RND_ZERO || mode == FPU_RND_UPWARD) {
+
+            flags |= FPEXP_OVFL | FPEXP_INEX2;
+            raw = *((u32 *)&minflt);
+
+        } else {
+
+            flags |= FPEXP_OVFL | FPEXP_INEX2;
+            raw = *((u32 *)&neginf);
+        }
+
+    } else {
+
+        softfloat::float_exception_flags = 0;
+        raw = floatx80_to_float32(value.raw);
+
+        if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+            flags |= FPEXP_INEX2;
+        }
+        if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+            flags |= FPEXP_OVFL;
+        }
+        if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+            flags |= FPEXP_UNFL;
+        }
+    }
+    handler(flags);
+}
+
+FpuSingle::FpuSingle(const FPUReg &reg, ExcHandler handler)
+{
+    *this = FpuSingle(reg.val, handler);
+}
+
+FpuSingle::FpuSingle(float value)
+{
+    raw = *((u32 *)&value);
+}
+
+bool
+FpuSingle::signbit() const
+{
+    return raw & (1 << 31);
+}
+
+bool
+FpuSingle::isinf() const
+{
+    float fval = *((float *)&raw);
+    return std::isinf(fval);
+}
+
+bool
+FpuSingle::isposinf() const
+{
+    return isinf() && !signbit();
+}
+
+bool
+FpuSingle::isneginf() const
+{
+    return isinf() && signbit();
+}
+
+
+//
+// FpuDouble
+//
+
+FpuDouble::FpuDouble(double value)
+{
+    raw = *((u64 *)&value);
+}
+
+FpuDouble::FpuDouble(const class FpuExtended &value, ExcHandler handler)
+{
+    u32 flags = 0;
+    softfloat::float_exception_flags = 0;
+
+    raw = floatx80_to_float64(value.raw);
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        flags |= FPEXP_INEX2;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        flags |= FPEXP_OVFL;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        flags |= FPEXP_UNFL;
+    }
+
+    handler(flags);
+}
+
+FpuDouble::FpuDouble(const FPUReg &reg, ExcHandler handler) : FpuDouble(reg.val, handler) { }
+
+bool
+FpuDouble::signbit() const
+{
+    return raw & (1L << 63);
+}
+
+bool
+FpuDouble::isinf() const
+{
+    double dval = *((double *)&raw);
+    return std::isinf(dval);
+}
+
+bool
+FpuDouble::isposinf() const
+{
+    return isinf() && !signbit();
+}
+
+bool
+FpuDouble::isneginf() const
+{
+    return isinf() && signbit();
+}
+
+
+//
+// FpuExtended
+//
+
+FpuExtended FpuExtended::nan     = FpuExtended(0x7FFF, 0xFFFFFFFFFFFFFFFF);
+FpuExtended FpuExtended::zero    = FpuExtended(0x0000, 0x0000000000000000);
+FpuExtended FpuExtended::posZero = FpuExtended(0x0000, 0x0000000000000000);
+FpuExtended FpuExtended::negZero = FpuExtended(0x8000, 0x0000000000000000);
+FpuExtended FpuExtended::inf     = FpuExtended(0x7FFF, 0x0000000000000000);
+FpuExtended FpuExtended::posInf  = FpuExtended(0x7FFF, 0x0000000000000000);
+FpuExtended FpuExtended::negInf  = FpuExtended(0xFFFF, 0x0000000000000000);
+
+FpuExtended::FpuExtended(const FpuByte &value, ExcHandler handler)
+{
+    u32 flags = 0;
+    softfloat::float_exception_flags = 0;
+
+    raw = softfloat::int64_to_floatx80(value.raw);
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        flags |= FPEXP_INEX2;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        flags |= FPEXP_OVFL;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        flags |= FPEXP_UNFL;
+    }
+
+    handler(flags);
+}
+
+FpuExtended::FpuExtended(const FpuWord &value, ExcHandler handler)
+{
+    u32 flags = 0;
+    softfloat::float_exception_flags = 0;
+
+    raw = softfloat::int64_to_floatx80(value.raw);
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        flags |= FPEXP_INEX2;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        flags |= FPEXP_OVFL;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        flags |= FPEXP_UNFL;
+    }
+
+    handler(flags);
+}
+
+FpuExtended::FpuExtended(const FpuLong &value, ExcHandler handler)
+{
+    u32 flags = 0;
+    softfloat::float_exception_flags = 0;
+
+    raw = softfloat::int32_to_floatx80(value.raw);
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        flags |= FPEXP_INEX2;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        flags |= FPEXP_OVFL;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        flags |= FPEXP_UNFL;
+    }
+
+    handler(flags);
+}
+
+FpuExtended::FpuExtended(const FpuSingle &value, ExcHandler handler)
+{
+    if (value.isposinf()) { *this = FpuExtended::posInf; return; }
+    if (value.isneginf()) { *this = FpuExtended::negInf; return; }
+
+    u32 flags = 0;
+    softfloat::float_exception_flags = 0;
+    
+    raw = softfloat::float32_to_floatx80(value.raw);
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        flags |= FPEXP_INEX2;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        flags |= FPEXP_OVFL;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        flags |= FPEXP_UNFL;
+    }
+
+    handler(flags);
+}
+
+FpuExtended::FpuExtended(const FpuDouble &value, ExcHandler handler)
+{
+    if (value.isposinf()) { *this = FpuExtended::posInf; return; }
+    if (value.isneginf()) { *this = FpuExtended::negInf; return; }
+
+    u32 flags = 0;
+    softfloat::float_exception_flags = 0;
+
+    raw = softfloat::float64_to_floatx80(value.raw);
+
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        flags |= FPEXP_INEX2;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        flags |= FPEXP_OVFL;
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        flags |= FPEXP_UNFL;
+    }
+
+    handler(flags);
+}
+
+FpuExtended::FpuExtended(const FpuPacked &packed, FpuRoundingMode mode, ExcHandler handler)
+{
+    char str[128], *ch = str;
+    i32 ex = 0; u64 mal = 0, mar = 0;
+
+    auto dw1 = packed.data[0];
+    auto dw2 = packed.data[1];
+    auto dw3 = packed.data[2];
+
+    // Extract the sign bits
+    auto msign = bool(dw1 & 0x80000000);
+    auto esign = bool(dw1 & 0x40000000);
+
+    // Compose the exponent
+    ex = (char)((dw1 >> 24) & 0xF);
+    ex = ex * 10 + (char)((dw1 >> 20) & 0xF);
+    ex = ex * 10 + (char)((dw1 >> 16) & 0xF);
+
+    // Compose the fractional part of the mantissa
+    mar = (char)((dw2 >> 28) & 0xF);
+    mar = mar * 10 + (char)((dw2 >> 24) & 0xF);
+    mar = mar * 10 + (char)((dw2 >> 20) & 0xF);
+    mar = mar * 10 + (char)((dw2 >> 16) & 0xF);
+    mar = mar * 10 + (char)((dw2 >> 12) & 0xF);
+    mar = mar * 10 + (char)((dw2 >> 8)  & 0xF);
+    mar = mar * 10 + (char)((dw2 >> 4)  & 0xF);
+    mar = mar * 10 + (char)((dw2 >> 0)  & 0xF);
+    mar = mar * 10 + (char)((dw3 >> 28) & 0xF);
+    mar = mar * 10 + (char)((dw3 >> 24) & 0xF);
+    mar = mar * 10 + (char)((dw3 >> 20) & 0xF);
+    mar = mar * 10 + (char)((dw3 >> 16) & 0xF);
+    mar = mar * 10 + (char)((dw3 >> 12) & 0xF);
+    mar = mar * 10 + (char)((dw3 >> 8)  & 0xF);
+    mar = mar * 10 + (char)((dw3 >> 4)  & 0xF);
+    mar = mar * 10 + (char)((dw3 >> 0)  & 0xF);
+
+    // Compose the integer part of the mantissa
+    mal = (char)((dw1 >> 0) & 0xF);
+    mal += mar / 10000000000000000;
+    mar %= 10000000000000000;
+
+    // Check for special cases
+    if (ex == 1665) {
+
+        if (mar == 0) {
+
+            if (((dw1 >> 28) & 0x7) == 0x7) {
+                *this = FpuExtended(msign ? 0xFFFF : 0x7FFF, 0); // Infinity
+                return;
+            } else {
+                *this = FpuExtended(msign ? 0x8000 : 0, 0); // ?
+                return;
+            }
+
+        } else {
+
+            if (((dw1 >> 28) & 0x7) == 0x7) {
+                *this = FpuExtended(msign ? 0xFFFF : 0x7FFF, u64(dw2) << 32 | dw3); // NaN
+                return;
+            } else {
+                // *this = Float80(msign ? 0x8000 : 0, 0); // ?
+                // return;
+            }
+        }
+    }
+
+    // Write the integer part of the mantissa
+    if (msign) *ch++ = '-';
+    for (int i = 1; i >= 0; i--) { ch[i] = (mal % 10) + '0'; mal /= 10; }
+    ch += 2;
+
+    // Write the fractional part of the mantissa
+    *ch++ = '.';
+    for (int i = 15; i >= 0; i--) { ch[i] = (mar % 10) + '0'; mar /= 10; }
+    ch += 16;
+
+    // Write the exponent
+    *ch++ = 'E';
+    if (esign) *ch++ = '-';
+    for (int i = 3; i >= 0; i--) { ch[i] = (ex % 10) + '0'; ex /= 10; }
+    ch += 4;
+
+    // Terminate the string
+    *ch = 0;
+
+    *this = FpuExtended(str, mode, handler);
+}
+
+FpuExtended::FpuExtended(const std::string &s, FpuRoundingMode mode, ExcHandler handler)
+{
+    long double value;
+
+    auto old = FPU::fesetround(mode);
+    sscanf(s.c_str(), "%Le", &value);
+    FPU::fesetround(old);
+
+    *this = FpuExtended(value, mode);
+    normalize();
+}
+
+FpuExtended::FpuExtended(long double value, FpuRoundingMode mode, ExcHandler handler)
+{
+    // Handle special cases
+    if (value == 0.0) {
+
+        *this = std::signbit(value) ? negZero : posZero;
+        return;
+    }
+    if (std::isinf(value)) {
+
+        *this = std::signbit(value) ? negInf : posInf;
+        return;
+    }
+
+    // Extract the exponent and the mantissa
+    int e; auto m = frexpl(value, &e);
+
+    // Subtract one, because the first digit is left of the comma
+    e -= 1;
+
+    // Round the mantissa
+    switch (mode) {
+        case FPU_RND_NEAREST:   m = std::round(std::ldexpl(m, 64)); break;
+        case FPU_RND_ZERO:      m = std::truncl(std::ldexpl(m, 64)); break;
+        case FPU_RND_UPWARD:    m = std::ceill(std::ldexpl(m, 64)); break;
+        default:                m = std::floorl(std::ldexpl(m, 64)); break;
+    }
+
+    printf("e = %d m = %Lf %llu\n", e, m, (u64)m);
+
+    // Compose the result
+    *this = FpuExtended(value < 0.0, e, (u64)std::abs(m), handler);
+}
+
+FpuExtended::FpuExtended(bool mSign, i64 e, u64 m, ExcHandler handler)
+{
+    if (e < -0x3FFF) {
+        
+        printf("UNDERFLOW e = %lld\n", e);
+        *this = zero;
+        handler(FPEXP_UNFL);
+        return;
+    }
+    if (e > 0x3FFF) {
+
+        printf("OVERFLOW e = %lld\n", e);
+        *this = inf.copysign(mSign);
+        handler(FPEXP_OVFL);
+        return;
+    }
+
+    raw.high = (mSign ? 0x8000 : 0x0000) | (u16(e + 0x3FFF) & 0x7FFF);
+    raw.low = m;
+}
+
+long double
+FpuExtended::asLongDouble() const
+{
+    if (isinf()) {
+        return std::copysignl(std::numeric_limits<long double>::infinity(), signbit() ? -1.0L : 1.0L);
+    }
+    if (isnan()) {
+        return std::copysignl(std::numeric_limits<long double>::quiet_NaN(), signbit() ? -1.0L : 1.0L);
+    }
+
+    auto result = std::ldexpl((long double)man(), (int)exp() - 63);
+    return signbit() ? -result : result;
+}
+
+FpuExtended
+FpuExtended::operator-() const
+{
+    auto result = *this;
+    result.raw.high ^= 0x8000;
+    return result;
+}
+
+bool
+FpuExtended::operator==(const FpuExtended& rhs) const
+{
+    // return softfloat::floatx80_eq(this->raw, rhs.raw);
+    return this->raw.high == rhs.raw.high && this->raw.low == rhs.raw.low;
+}
+
+bool
+FpuExtended::operator!=(const FpuExtended& rhs) const
+{
+    // return !softfloat::floatx80_eq(this->raw, rhs.raw);
+    return this->raw.high != rhs.raw.high || this->raw.low != rhs.raw.low;
+}
+
+bool
+FpuExtended::operator<=(const FpuExtended& rhs) const
+{
+    return softfloat::floatx80_le(this->raw, rhs.raw);
+}
+
+bool
+FpuExtended::operator>=(const FpuExtended& rhs) const
+{
+    return rhs <= *this;
+}
+
+bool
+FpuExtended::operator<(const FpuExtended& rhs) const
+{
+    return softfloat::floatx80_lt(this->raw, rhs.raw);
+}
+
+bool
+FpuExtended::operator>(const FpuExtended& rhs) const
+{
+    return rhs < *this; 
+}
+
+int
+FpuExtended::fpclassify() const
+{
+    if (isinf()) return FP_INFINITE;
+    if (isnan()) return FP_NAN;
+    if (iszero()) return FP_ZERO;
+    if (issubnormal()) return FP_SUBNORMAL;
+
+    return FP_NORMAL;
+}
+
+void
+FpuExtended::normalize()
+{
+    if (!minexp() && !maxexp() && man()) {
+        
+        while (!isnormal()) {
+            
+            raw.high -= 1;
+            raw.low <<= 1;
+        }
+    }
+}
+
+std::pair<int, long double>
+FpuExtended::frexp10() const
+{
+    long double val = asLongDouble();
+    int e = iszero() ? 0 : 1 + (int)std::floor(std::log10(std::fabs(val)));
+    long double m = val * std::powl(10L, -e);
+
+    return { e, m };
+};
+
+FpuExtended
+FpuExtended::copysign(bool sign)
+{
+    if (sign) {
+        return FpuExtended(raw.high | 0x8000, raw.low);
+    } else {
+        return FpuExtended(raw.high & 0x7FFF, raw.low);
+    }
+}
+
+FpuExtended
+FpuExtended::copysign(const FpuExtended &other)
+{
+    return copysign(other.signbit());
+}
+
+
+//
+// FpuPacked
+//
+
+FpuPacked::FpuPacked(const FpuExtended &value, int k, FpuRoundingMode mode, ExcHandler handler)
+{
+    u32 statusbits = 0;
+
+    // Get exponent
+    auto e = value.frexp10().first - 1;
+
+    // Check k-factor
+    if (k > 17) {
+        statusbits = FPEXP_OPERR | FPEXP_INEX2;
+        k = 17;
+    }
+    if (k < -17) {
+        k = -17;
+    }
+
+    // Setup stringstream
+    std::stringstream ss;
+    long double test;
+    ss.setf(std::ios::scientific, std::ios::floatfield);
+    ss.precision(k > 0 ? k - 1 : e - k);
+
+    // Create string representation
+    auto ldval = value.asLongDouble();
+    auto old = FPU::fesetround(mode);
+    ss << ldval;
+    std::stringstream ss2(ss.str());
+    ss2 >> test;
+    FPU::fesetround(old);
+
+    if (ldval != test) {
+        statusbits |= FPEXP_INEX2;
+    }
+    
+    // Assemble exponent
+    data[0] = e < 0 ? 0x40000000 : 0;
+    data[0] |= (e % 10) << 16; e /= 10;
+    data[0] |= (e % 10) << 20; e /= 10;
+    data[0] |= (e % 10) << 24;
+
+    // Assemble mantisse
+    char c;
+    int shift = 64;
+
+    while (ss.get(c)) {
+
+        if (c == '+') continue;
+        if (c == '-') data[0] |= 0x80000000;
+        if (c >= '0' && c <= '9') {
+            if (shift == 64) data[0] |= u32(c - '0');
+            else if (shift >= 32) data[1] |= u32(c - '0') << (shift - 32);
+            else if (shift >= 0) data[2] |= u32(c - '0') << shift;
+            shift -= 4;
+        }
+        if (c == 'e' || c ==  'E') break;
+    }
+
+    handler(statusbits);
+}
+
+FpuPacked::FpuPacked(const FPUReg &reg, int k, FpuRoundingMode mode,
+                     ExcHandler handler) : FpuPacked(reg.val, k, mode, handler) { }
+
+}
diff --git a/Emulator/Components/CPU/Moira/FpuFormats.h b/Emulator/Components/CPU/Moira/FpuFormats.h
new file mode 100644
index 000000000..0029793fd
--- /dev/null
+++ b/Emulator/Components/CPU/Moira/FpuFormats.h
@@ -0,0 +1,222 @@
+// -----------------------------------------------------------------------------
+// This file is part of Moira - A Motorola 68k emulator
+//
+// Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
+// Published under the terms of the MIT License
+// -----------------------------------------------------------------------------
+
+#pragma once
+
+#include "MoiraTypes.h"
+#include "softfloat.h"
+#include <functional>
+
+namespace vamiga::moira {
+
+/* The Motorola floating-point unit supports seven data formats:
+ *
+ *    Byte Integer (B)
+ *    Word Integer (W)
+ *    Long Word Integer (L)
+ *    Single Precision Real (S)
+ *    Double Precision Real (D)
+ *    Extended Precision Real (X)
+ *    Packed Decimal String Real (P)
+ *
+ * Each of these formats is managed by a seperate struct.
+ */
+
+struct FpuByte;
+struct FpuWord;
+struct FpuLong;
+struct FpuSingle;
+struct FpuDouble;
+struct FpuExtended;
+struct FpuPacked;
+
+class FPUReg;
+
+typedef std::function<void(u32)> ExcHandler;
+
+
+//
+// FpuByte
+//
+
+struct FpuByte {
+
+    i8 raw;
+
+    FpuByte() : raw(0) { };
+    FpuByte(i8 value) : raw(value) { };
+    FpuByte(u32 value) : raw((i8)value) { };
+    FpuByte(const FpuExtended &value, ExcHandler handler = [](auto&&...) {});
+    FpuByte(const FPUReg &value, ExcHandler handler = [](auto&&...) {});
+};
+
+
+//
+// FpuWord
+//
+
+struct FpuWord {
+
+    i16 raw;
+
+    FpuWord() : raw(0) { };
+    FpuWord(i16 value) : raw(value) { };
+    FpuWord(u32 value) : raw((i16)value) { };
+    FpuWord(const FpuExtended &value, ExcHandler handler = [](auto&&...) {});
+    FpuWord(const FPUReg &value, ExcHandler handler = [](auto&&...) {});
+};
+
+
+//
+// FpuLong
+//
+
+struct FpuLong {
+
+    i32 raw;
+
+    FpuLong() : raw(0) { };
+    FpuLong(i32 value) : raw(value) { };
+    FpuLong(u32 value) : raw((i32)value) { };
+    FpuLong(const FpuExtended &value, ExcHandler handler = [](auto&&...) {});
+    FpuLong(const FPUReg &value, ExcHandler handler = [](auto&&...) {});
+};
+
+
+//
+// FpuSingle
+//
+
+struct FpuSingle {
+
+    u32 raw;
+
+    FpuSingle() : raw(0) { };
+    FpuSingle(u32 value) : raw(value) { };
+    FpuSingle(float value);
+    FpuSingle(const FpuExtended &value, ExcHandler handler = [](auto&&...) {});
+    FpuSingle(const FpuExtended &value, FpuRoundingMode mode, ExcHandler handler = [](auto&&...) {});
+    FpuSingle(const FPUReg &value, ExcHandler handler = [](auto&&...) {});
+
+    bool signbit() const;
+    bool isinf() const;
+    bool isposinf() const;
+    bool isneginf() const;
+};
+
+
+//
+// FpuDouble
+//
+
+struct FpuDouble {
+
+    u64 raw;
+
+    FpuDouble() : raw(0) { };
+    FpuDouble(u64 value) : raw(value) { };
+    FpuDouble(u32 hi, u32 lo) : raw(u64(hi) << 32 | lo) { };
+    FpuDouble(double value);
+    FpuDouble(const FpuExtended &value, ExcHandler handler = [](auto&&...) {});
+    FpuDouble(const class FPUReg &value, ExcHandler handler = [](auto&&...) {});
+
+    bool signbit() const;
+    bool isinf() const;
+    bool isposinf() const;
+    bool isneginf() const;
+};
+
+
+//
+// FpuExtended
+//
+
+struct FpuExtended {
+
+    softfloat::floatx80 raw;
+
+    // Constants
+    static constexpr i64 bias = 0x3FFF;
+
+    static FpuExtended nan;
+    static FpuExtended zero;
+    static FpuExtended posZero;
+    static FpuExtended negZero;
+    static FpuExtended inf;
+    static FpuExtended posInf;
+    static FpuExtended negInf;
+
+    // Constructors
+    FpuExtended() { raw = { }; }
+    FpuExtended(u32 hi, u64 lo) { raw.high = u16(hi); raw.low = lo; }
+    FpuExtended(u32 hi, u32 lo1, u32 lo2) { raw.high = u16(hi); raw.low = u64(lo1) << 32 | lo2; }
+    FpuExtended(const FpuByte &value, ExcHandler handler = [](auto&&...) {});
+    FpuExtended(const FpuWord &value, ExcHandler handler = [](auto&&...) {});
+    FpuExtended(const FpuLong &value, ExcHandler handler = [](auto&&...) {});
+    FpuExtended(const FpuSingle &value, ExcHandler handler = [](auto&&...) {});
+    FpuExtended(const FpuDouble &value, ExcHandler handler = [](auto&&...) {});
+    FpuExtended(const FpuPacked &value, FpuRoundingMode mode, ExcHandler handler = [](auto&&...) {});
+    FpuExtended(const std::string &s, FpuRoundingMode mode, ExcHandler handler = [](auto&&...) {});
+    FpuExtended(long double value, FpuRoundingMode mode = FPU_RND_NEAREST, ExcHandler handler = [](auto&&...) {});
+    FpuExtended(bool mSign, i64 e, u64 m, ExcHandler handler = [](auto&&...) {});
+
+    // Converters
+    long double asLongDouble() const;
+
+    // Operators
+    FpuExtended operator-() const;
+    bool operator==(const FpuExtended& rhs) const;
+    bool operator!=(const FpuExtended& rhs) const;
+    bool operator<=(const FpuExtended& rhs) const;
+    bool operator>=(const FpuExtended& rhs) const;
+    bool operator<(const FpuExtended& rhs) const;
+    bool operator>(const FpuExtended& rhs) const;
+
+    // Analyzers
+    bool signbit() const { return raw.high & 0x8000; }
+    i64 exp() const { return i64(raw.high & 0x7FFF) - bias; }
+    u64 man() const { return raw.low; }
+    bool minexp() const { return (raw.high & 0x7FFF) == 0; }
+    bool maxexp() const { return (raw.high & 0x7FFF) == 0x7FFF; }
+    bool m62() const { return raw.low & (1L << 62); }
+    bool m63() const { return raw.low & (1L << 63); }
+
+    int fpclassify() const;
+    bool isfinite() const { return !isnan() && !isinf(); }
+    bool isinf() const { return (raw.high & 0x7FFF) == 0x7FFF && raw.low == 0; }
+    bool isnan() const { return (raw.high & 0x7FFF) == 0x7FFF && raw.low != 0; }
+    bool isSignalingNaN() const { return isnan() && !m62(); }
+    bool isNonsignalingNaN() const { return isnan() && m62(); }
+    bool isnormal() const { return !minexp() && !maxexp() && m63(); }
+    bool issubnormal() const { return (raw.high & 0x7FFF) == 0 && raw.low && !m63(); }
+    bool isnegative() const { return signbit(); }
+    bool ispositive() const { return !signbit(); }
+    bool iszero() const { return (raw.high & 0x7FFF) == 0 && raw.low == 0; }
+
+    // Misc
+    void normalize();
+    std::pair<int, long double> frexp10() const;
+    FpuExtended copysign(bool sign);
+    FpuExtended copysign(const FpuExtended &other);
+};
+
+
+//
+// FpuPacked
+//
+
+struct FpuPacked {
+
+    u32 data[3] = { };
+
+    FpuPacked() { }
+    FpuPacked(u32 dw1, u32 dw2, u32 dw3) { data[0] = dw1; data[1] = dw2; data[2] = dw3; }
+    FpuPacked(const FpuExtended &value, int kfactor, FpuRoundingMode mode, ExcHandler handler = [](auto&&...) {});
+    FpuPacked(const class FPUReg &value, int kfactor, FpuRoundingMode mode, ExcHandler handler = [](auto&&...) {});
+};
+
+}
diff --git a/Emulator/Components/CPU/Moira/Moira.cpp b/Emulator/Components/CPU/Moira/Moira.cpp
index b376ad853..801c93a9f 100644
--- a/Emulator/Components/CPU/Moira/Moira.cpp
+++ b/Emulator/Components/CPU/Moira/Moira.cpp
@@ -60,17 +60,58 @@ Moira::~Moira()
 void
 Moira::setModel(Model cpuModel, Model dasmModel)
 {
-    // Only proceed if the model changes
-    if (this->cpuModel == cpuModel && this->dasmModel == dasmModel) return;
+    if (this->cpuModel != cpuModel || this->dasmModel != dasmModel) {
+        
+        this->cpuModel = cpuModel;
+        this->dasmModel = dasmModel;
+        
+        // Reset the FPU core if no external co-processor is present
+        // if (!has6888x()) fpu.setModel(INTERNAL_FPU);
+        
+        createJumpTable(cpuModel, dasmModel);
+        
+        reg.cacr &= cacrMask();
+        flags &= ~CPU_IS_LOOPING;
+    }
+}
+
+void
+Moira::setFpuModel(FPUModel model)
+{
+    if (fpu.getModel() != model) {
+        
+        fpu.setModel(model);
+        createJumpTable(cpuModel, dasmModel);
+    }
+}
+
+/*
+void
+Moira::attach6888x(int x)
+{
+    assert(x == 1 || x == 2);
 
-    this->cpuModel = cpuModel;
-    this->dasmModel = dasmModel;
+    FPUModel model = x == 1 ? M68881 : M68882;
 
-    createJumpTable(cpuModel, dasmModel);
+    if (fpu.getModel() != model) {
+
+        fpu.setModel(model);
+        createJumpTable(cpuModel, dasmModel);
+    }
+}
+
+void
+Moira::detach6888x()
+{
+    FPUModel model = hasFPU() ? INTERNAL_FPU : NO_FPU;
+
+    if (fpu.getModel() != model) {
 
-    reg.cacr &= cacrMask();
-    flags &= ~CPU_IS_LOOPING;
+        fpu.setModel(model);
+        createJumpTable(cpuModel, dasmModel);
+    }
 }
+*/
 
 void
 Moira::setDasmSyntax(DasmSyntax value)
@@ -101,7 +142,7 @@ Moira::setNumberFormat(DasmStyle &style, const DasmNumberFormat &value)
 }
 
 bool
-Moira::hasCPI()
+Moira::hasCPI() const
 {
     switch (cpuModel) {
 
@@ -114,7 +155,7 @@ Moira::hasCPI()
 }
 
 bool
-Moira::hasMMU()
+Moira::hasMMU() const
 {
     switch (cpuModel) {
 
@@ -127,7 +168,7 @@ Moira::hasMMU()
 }
 
 bool
-Moira::hasFPU()
+Moira::hasFPU() const
 {
     switch (cpuModel) {
 
@@ -161,6 +202,12 @@ Moira::addrMask() const
     }
 }
 
+bool
+Moira::has6888x() const
+{
+    return fpu.getModel() == M68881 || fpu.getModel() == M68882;
+}
+
 template <Core C> u32
 Moira::addrMask() const
 {
@@ -196,8 +243,6 @@ Moira::reset()
     fcl = 0;
     fcSource = 0;
 
-    fpu = { };
-
     SYNC(16);
 
     // Read the initial (supervisor) stack pointer from memory
@@ -216,6 +261,8 @@ Moira::reset()
     SYNC(2);
     prefetch<C>();
 
+    // Reset subcomponents
+    fpu.reset();
     debugger.reset();
 
     // Inform the delegate
@@ -379,7 +426,7 @@ Moira::processException(const std::exception &exc)
             throw df;
         }
 
-    } catch (DoubleFault & df) {
+    } catch (DoubleFault &df) {
 
         halt();
         return;
diff --git a/Emulator/Components/CPU/Moira/Moira.h b/Emulator/Components/CPU/Moira/Moira.h
index f38ff594d..5d2fd96c1 100644
--- a/Emulator/Components/CPU/Moira/Moira.h
+++ b/Emulator/Components/CPU/Moira/Moira.h
@@ -9,6 +9,7 @@
 
 #include "MoiraConfig.h"
 #include "MoiraTypes.h"
+#include "MoiraFPU.h"
 #include "MoiraDebugger.h"
 #include "SubComponent.h"
 
@@ -16,6 +17,7 @@ namespace vamiga::moira {
 
 class Moira : public SubComponent {
 
+    friend class FPU;
     friend class Debugger;
     friend class Breakpoints;
     friend class Watchpoints;
@@ -47,6 +49,9 @@ class Moira : public SubComponent {
 
 public:
 
+    // Floating point unit (not supported yet)
+    FPU fpu = FPU(*this);
+
     // Breakpoints, watchpoints, catchpoints, instruction tracing
     Debugger debugger = Debugger(*this);
 
@@ -66,9 +71,6 @@ class Moira : public SubComponent {
     // The prefetch queue
     PrefetchQueue queue;
 
-    // The floating point unit (not supported yet)
-    FPU fpu;
-
     // The interrupt mode of this CPU
     IrqMode irqMode = IRQ_AUTO;
 
@@ -150,6 +152,13 @@ class Moira : public SubComponent {
     void setModel(Model cpuModel, Model dasmModel);
     void setModel(Model model) { setModel(model, model); }
 
+    // Selects the emulated FPU model
+    void setFpuModel(FPUModel fpuModel);
+
+    // Attaches or detaches a floating-point coprocessor
+    // [[deprecated]] void attach6888x(int x);
+    // [[deprecated]] void detach6888x();
+
     // Configures the visual appearance of disassembled instructions
     void setDasmSyntax(DasmSyntax value);
     void setDasmNumberFormat(DasmNumberFormat value) { setNumberFormat(instrStyle, value); }
@@ -172,13 +181,13 @@ class Moira : public SubComponent {
 public:
 
     // Checks if the emulated CPU model has a coprocessor interface
-    bool hasCPI();
+    bool hasCPI() const;
 
     // Checks if the emulated CPU model has a memory managenemt unit
-    bool hasMMU();
+    bool hasMMU() const;
 
     // Checks if the emulated CPU model has a floating point unit
-    bool hasFPU();
+    bool hasFPU() const;
 
     // Returns the cache register mask (accessible CACR bits)
     u32 cacrMask() const;
@@ -186,6 +195,9 @@ class Moira : public SubComponent {
     // Returns the address bus mask (bus width)
     u32 addrMask() const;
 
+    // Checks if a floating-point coprocessor is attached
+    bool has6888x() const;
+
 protected:
 
     // The addrMask core routine
@@ -243,8 +255,8 @@ class Moira : public SubComponent {
     void dump32(char *str, u32 value) const;
 
     // Creates a textual representation for multiple data values
-    void dump16(char *str, u16 values[], isize cnt) const;
-    void dump16(char *str, u32 addr, isize cnt) const;
+    void dump16(char *str, u16 values[], int cnt) const;
+    void dump16(char *str, u32 addr, int cnt) const;
 
     // Return an info struct for a certain opcode
     InstrInfo getInfo(u16 op) const;
@@ -464,7 +476,7 @@ class Moira : public SubComponent {
     // Checks the validity of the extension words
     bool isValidExt(Instr I, Mode M, u16 op, u32 ext) const;
     bool isValidExtMMU(Instr I, Mode M, u16 op, u32 ext) const;
-    bool isValidExtFPU(Instr I, Mode M, u16 op, u32 ext) const;
+    // bool isValidExtFPU(Instr I, Mode M, u16 op, u32 ext) const;
 
     // Returns an availability string (used by the disassembler)
     const char *availabilityString(Instr I, Mode M, Size S, u16 ext);
diff --git a/Emulator/Components/CPU/Moira/MoiraConfig.h b/Emulator/Components/CPU/Moira/MoiraConfig.h
index 77fa16967..3f3019fe5 100644
--- a/Emulator/Components/CPU/Moira/MoiraConfig.h
+++ b/Emulator/Components/CPU/Moira/MoiraConfig.h
@@ -74,6 +74,18 @@
  */
 #define BUILD_INSTR_INFO_TABLE false
 
+/* Set to true to abort compilation on platforms with no long double support
+ *
+ * Some FPU functions make use of the "long double" type which is mapped to the
+ * standard "double" type on some platforms. On those platforms, the FPU can
+ * compute imprecise results, e.g., when reading a value in packed BCD format
+ * from memory. In practice, the implication of this imprecision will most
+ * likely be neglectable.
+ *
+ * Disable to allow small precision errors.
+ */
+#define REQUIRE_PRECISE_FPU false
+
 /* Set to true to run Moira in a special Musashi compatibility mode.
  *
  * The compatibility mode is used by the test runner application to compare
@@ -86,7 +98,74 @@
 /* The following macro appears at the beginning of each instruction handler.
  * Moira will call 'willExecute(...)' for all listed instructions.
  */
-#define WILL_EXECUTE    I == STOP || I == TAS || I == BKPT
+#define WILL_EXECUTE I == STOP || I == TAS || I == BKPT
+/*
+#define WILL_EXECUTE \
+I == FABS || \
+I == FADD || \
+I == FBcc || \
+I == FCMP || \
+I == FDBcc || \
+I == FDIV || \
+I == FMOVE || \
+I == FMOVEM || \
+I == FMUL || \
+I == FNEG || \
+I == FNOP || \
+I == FRESTORE || \
+I == FSAVE || \
+I == FScc || \
+I == FSQRT || \
+I == FSUB || \
+I == FTRAPcc || \
+I == FTST || \
+I == FSABS || \
+I == FDABS || \
+I == FSADD || \
+I == FDADD || \
+I == FSDIV || \
+I == FDDIV || \
+I == FSMOVE || \
+I == FDMOVE || \
+I == FSMUL || \
+I == FDMUL || \
+I == FSNEG || \
+I == FDNEG || \
+I == FSSQRT || \
+I == FDSQRT || \
+I == FSSUB || \
+I == FDSUB || \
+I == FACOS || \
+I == FASIN || \
+I == FATAN || \
+I == FATANH || \
+I == FCOS || \
+I == FCOSH || \
+I == FETOX || \
+I == FETOXM1 || \
+I == FGETEXP || \
+I == FGETMAN || \
+I == FINT || \
+I == FINTRZ || \
+I == FLOG10 || \
+I == FLOG2 || \
+I == FLOGN || \
+I == FLOGNP1 || \
+I == FMOD || \
+I == FMOVECR || \
+I == FREM || \
+I == FSCAL || \
+I == FSGLDIV || \
+I == FSGLMUL || \
+I == FSIN || \
+I == FSINCOS || \
+I == FSINH || \
+I == FTAN || \
+I == FTANH || \
+I == FTENTOX || \
+I == FTWOTOX
+*/
+// I == STOP || I == TAS || I == BKPT
 
 /* The following macro appear at the end of each instruction handler.
  * Moira will call 'didExecute(...)' for all listed instructions.
diff --git a/Emulator/Components/CPU/Moira/MoiraDasmFPU_cpp.h b/Emulator/Components/CPU/Moira/MoiraDasmFPU_cpp.h
index 1b262000b..dd44562fc 100644
--- a/Emulator/Components/CPU/Moira/MoiraDasmFPU_cpp.h
+++ b/Emulator/Components/CPU/Moira/MoiraDasmFPU_cpp.h
@@ -2,12 +2,57 @@
 // This file is part of Moira - A Motorola 68k emulator
 //
 // Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
-// Licensed under the GNU General Public License v3
-//
-// See https://www.gnu.org for license information
+// Published under the terms of the MIT License
 // -----------------------------------------------------------------------------
 
-// #include "softfloat.h"
+template <Instr I, Mode M, Size S> void
+Moira::dasmFBcc(StrWriter &str, u32 &addr, u16 op) const
+{
+    auto old = addr;
+    auto ext = dasmIncRead<S>(addr);
+    auto cnd = ___________xxxxx (op);
+
+    // Check for special FNOP opcode
+    if ((op & 0x7F) == 0 && ext == 0) {
+
+        dasmFNop<FNOP, M, S>(str, addr, op);
+        return;
+    }
+
+    auto dst = old + 2;
+    U32_INC(dst, SEXT<S>(ext));
+
+    if (S == Long) {
+        str << Ins<I>{} << Fcc{cnd} << Sz<S>{} << str.tab << UInt(dst);
+    } else {
+        str << Ins<I>{} << Fcc{cnd} << str.tab << UInt(dst);
+    }
+}
+
+template <Instr I, Mode M, Size S> void
+Moira::dasmFDbcc(StrWriter &str, u32 &addr, u16 op) const
+{
+    auto old = addr;
+    auto ext = dasmIncRead(addr);
+    auto src = _____________xxx (op);
+    auto cnd = ___________xxxxx (ext);
+
+    // Catch illegal extension words
+    if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
+
+        if (!fpu.isValidExt(I, M, op, ext)) {
+
+            addr = old;
+            dasmIllegal<I, M, S>(str, addr, op);
+            return;
+        }
+    }
+
+    auto dst = addr + 2;
+    U32_INC(dst, SEXT<S>(dasmIncRead<S>(addr)));
+
+    str << Ins<I>{} << Fcc{cnd} << str.tab << Dn{src} << Sep{} << UInt(dst);
+}
 
 template <Instr I, Mode M, Size S> void
 Moira::dasmFGen(StrWriter &str, u32 &addr, u16 op) const
@@ -103,71 +148,34 @@ Moira::dasmFGen(StrWriter &str, u32 &addr, u16 op) const
                 case 0x37: dasmFGeneric2<FSINCOS, M, S>(str, addr, op); return;
                 case 0x38: dasmFGeneric<FCMP, M, S>(str, addr, op); return;
                 case 0x3A: dasmFGeneric3<FTST, M, S>(str, addr, op); return;
-                case 0x41: dasmFGeneric<FSSQRT, M, S>(str, addr, op); return;
-                case 0x45: dasmFGeneric<FDSQRT, M, S>(str, addr, op); return;
-                case 0x58: dasmFGeneric<FSABS, M, S>(str, addr, op); return;
-                case 0x5A: dasmFGeneric<FSNEG, M, S>(str, addr, op); return;
-                case 0x5C: dasmFGeneric<FDABS, M, S>(str, addr, op); return;
-                case 0x5E: dasmFGeneric<FDNEG, M, S>(str, addr, op); return;
-                case 0x60: dasmFGeneric<FSDIV, M, S>(str, addr, op); return;
-                case 0x62: dasmFGeneric<FSADD, M, S>(str, addr, op); return;
-                case 0x63: dasmFGeneric<FSMUL, M, S>(str, addr, op); return;
-                case 0x64: dasmFGeneric<FDDIV, M, S>(str, addr, op); return;
-                case 0x66: dasmFGeneric<FDADD, M, S>(str, addr, op); return;
-                case 0x67: dasmFGeneric<FDMUL, M, S>(str, addr, op); return;
-                case 0x68: dasmFGeneric<FSSUB, M, S>(str, addr, op); return;
-                case 0x6C: dasmFGeneric<FDSUB, M, S>(str, addr, op); return;
             }
-            break;
-    }
-
-    dasmLineF<I, M, S>(str, addr, op);
-}
 
-template <Instr I, Mode M, Size S> void
-Moira::dasmFBcc(StrWriter &str, u32 &addr, u16 op) const
-{
-    auto old = addr;
-    auto ext = dasmIncRead<S>(addr);
-    auto cnd = ___________xxxxx (op);
-
-    // Check for special FNOP opcode
-    if ((op & 0x7F) == 0 && ext == 0) {
-
-        dasmFNop<FNOP, M, S>(str, addr, op);
-        return;
-    }
-
-    auto dst = old + 2;
-    U32_INC(dst, SEXT<S>(ext));
-
-    if (S == Long) {
-        str << Ins<I>{} << Fcc{cnd} << Sz<S>{} << str.tab << UInt(dst);
-    } else {
-        str << Ins<I>{} << Fcc{cnd} << str.tab << UInt(dst);
-    }
-}
-
-template <Instr I, Mode M, Size S> void
-Moira::dasmFDbcc(StrWriter &str, u32 &addr, u16 op) const
-{
-    auto old = addr;
-    auto ext = dasmIncRead(addr);
-    auto src = _____________xxx (op);
-    auto cnd = ___________xxxxx (ext);
-
-    // Catch illegal extension words
-    if ((str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) && !isValidExtFPU(I, M, op, ext)) {
+            // 68040 only instructions
+            if (hasFPU()) {
+
+                switch (cmd) {
+
+                    case 0x41: dasmFGeneric<FSSQRT, M, S>(str, addr, op); return;
+                    case 0x45: dasmFGeneric<FDSQRT, M, S>(str, addr, op); return;
+                    case 0x58: dasmFGeneric<FSABS, M, S>(str, addr, op); return;
+                    case 0x5A: dasmFGeneric<FSNEG, M, S>(str, addr, op); return;
+                    case 0x5C: dasmFGeneric<FDABS, M, S>(str, addr, op); return;
+                    case 0x5E: dasmFGeneric<FDNEG, M, S>(str, addr, op); return;
+                    case 0x60: dasmFGeneric<FSDIV, M, S>(str, addr, op); return;
+                    case 0x62: dasmFGeneric<FSADD, M, S>(str, addr, op); return;
+                    case 0x63: dasmFGeneric<FSMUL, M, S>(str, addr, op); return;
+                    case 0x64: dasmFGeneric<FDDIV, M, S>(str, addr, op); return;
+                    case 0x66: dasmFGeneric<FDADD, M, S>(str, addr, op); return;
+                    case 0x67: dasmFGeneric<FDMUL, M, S>(str, addr, op); return;
+                    case 0x68: dasmFGeneric<FSSUB, M, S>(str, addr, op); return;
+                    case 0x6C: dasmFGeneric<FDSUB, M, S>(str, addr, op); return;
+                }
+            }
 
-        addr = old;
-        dasmIllegal<I, M, S>(str, addr, op);
-        return;
+            break;
     }
 
-    auto dst = addr + 2;
-    U32_INC(dst, SEXT<S>(dasmIncRead<S>(addr)));
-
-    str << Ins<I>{} << Fcc{cnd} << str.tab << Dn{src} << Sep{} << UInt(dst);
+    dasmLineF<I, M, S>(str, addr, op);
 }
 
 template <Instr I, Mode M, Size S> void
@@ -202,11 +210,14 @@ Moira::dasmFScc(StrWriter &str, u32 &addr, u16 op) const
     auto cnd = __________xxxxxx (ext);
 
     // Catch illegal extension words
-    if ((str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) && !isValidExtFPU(I, M, op, ext)) {
+    if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        addr = old;
-        dasmIllegal<I, M, S>(str, addr, op);
-        return;
+        if (!fpu.isValidExt(I, M, op, ext)) {
+
+            addr = old;
+            dasmIllegal<I, M, S>(str, addr, op);
+            return;
+        }
     }
 
     str << Ins<I>{} << Fcc{cnd} << str.tab << Op<M, S>(reg, addr);
@@ -220,11 +231,14 @@ Moira::dasmFTrapcc(StrWriter &str, u32 &addr, u16 op) const
     auto cnd = __________xxxxxx (ext);
 
     // Catch illegal extension words
-    if ((str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) && !isValidExtFPU(I, M, op, ext)) {
+    if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        addr = old;
-        dasmIllegal<I, M, S>(str, addr, op);
-        return;
+        if (!fpu.isValidExt(I, M, op, ext)) {
+
+            addr = old;
+            dasmIllegal<I, M, S>(str, addr, op);
+            return;
+        }
     }
 
     switch (S) {
@@ -447,7 +461,7 @@ Moira::dasmFMove(StrWriter &str, u32 &addr, u16 op) const
     // Catch illegal extension words
     if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        if (!isValidExtFPU(I, M, op, ext)) {
+        if (!fpu.isValidExt(I, M, op, ext)) {
 
             addr = old;
             dasmIllegal<I, M, S>(str, addr, op);
@@ -554,7 +568,7 @@ Moira::dasmFMovecr(StrWriter &str, u32 &addr, u16 op) const
     // Catch illegal extension words
     if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        if (!isValidExtFPU(I, M, op, ext)) {
+        if (!fpu.isValidExt(I, M, op, ext)) {
 
             addr = old;
             dasmIllegal<I, M, S>(str, addr, op);
@@ -579,7 +593,7 @@ Moira::dasmFMovem(StrWriter &str, u32 &addr, u16 op) const
     // Catch illegal extension words
     if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        if (!isValidExtFPU(I, M, op, ext)) {
+        if (!fpu.isValidExt(I, M, op, ext)) {
 
             addr = old;
             dasmIllegal<I, M, S>(str, addr, op);
@@ -613,7 +627,7 @@ Moira::dasmFMovem(StrWriter &str, u32 &addr, u16 op) const
 
                 if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-                    str << "fmovel" << str.tab << Sep{} << Op<M, Long>(reg, addr);
+                    str << Ins<FMOVE>{} << Ffmt{0} << str.tab << Sep{} << Op<M, Long>(reg, addr);
                     return;
                 }
             }
diff --git a/Emulator/Components/CPU/Moira/MoiraDasmMMU_cpp.h b/Emulator/Components/CPU/Moira/MoiraDasmMMU_cpp.h
index c1e2f31d7..c9119d72a 100644
--- a/Emulator/Components/CPU/Moira/MoiraDasmMMU_cpp.h
+++ b/Emulator/Components/CPU/Moira/MoiraDasmMMU_cpp.h
@@ -2,9 +2,7 @@
 // This file is part of Moira - A Motorola 68k emulator
 //
 // Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
-// Licensed under the GNU General Public License v3
-//
-// See https://www.gnu.org for license information
+// Published under the terms of the MIT License
 // -----------------------------------------------------------------------------
 
 template <Instr I, Mode M, Size S> void
diff --git a/Emulator/Components/CPU/Moira/MoiraDasm_cpp.h b/Emulator/Components/CPU/Moira/MoiraDasm_cpp.h
index 5a68b41a1..576ac84e0 100644
--- a/Emulator/Components/CPU/Moira/MoiraDasm_cpp.h
+++ b/Emulator/Components/CPU/Moira/MoiraDasm_cpp.h
@@ -92,25 +92,25 @@ Moira::dump32(char *str, u32 value) const
 }
 
 void
-Moira::dump16(char *str, u16 values[], isize cnt) const
+Moira::dump16(char *str, u16 values[], int cnt) const
 {
     StrWriter writer(str, dataStyle);
 
     for (int i = 0; i < cnt; i++) {
 
-        for (isize j = 0; i && j < dataStyle.tab; j++) writer << ' ';
+        for (int j = 0; i && j < dataStyle.tab; j++) writer << ' ';
         writer << UInt16{values[i]} << Finish{};
     }
 }
 
 void
-Moira::dump16(char *str, u32 addr, isize cnt) const
+Moira::dump16(char *str, u32 addr, int cnt) const
 {
     StrWriter writer(str, dataStyle);
 
     for (int i = 0; i < cnt; i++) {
 
-        for (isize j = 0; i && j < dataStyle.tab; j++) writer << ' ';
+        for (int j = 0; i && j < dataStyle.tab; j++) writer << ' ';
         writer << UInt16{u16(dasmRead<Word>(addr))} << Finish{};
         U32_INC(addr, 2);
     }
@@ -462,7 +462,7 @@ Moira::dasmAndiRg(StrWriter &str, u32 &addr, u16 op) const
     auto dst = _____________xxx(op);
 
     if (str.style.syntax == DASM_MUSASHI) {
-        str << Ins<I>{} << Sz<S>{} << str.tab << Imu{src} << Sep{} << Dn{dst};
+        str << Ins<I>{} << Sz<S>{} << str.tab << Imu<S>{src} << Sep{} << Dn{dst};
     } else {
         str << Ins<I>{} << Sz<S>{} << str.tab << Ims<S>(src) << Sep{} << Dn{dst};
     }
@@ -475,7 +475,7 @@ Moira::dasmAndiEa(StrWriter &str, u32 &addr, u16 op) const
     auto dst = Op <M,S> ( _____________xxx(op), addr );
 
     if (str.style.syntax == DASM_MUSASHI) {
-        str << Ins<I>{} << Sz<S>{} << str.tab << Imu{src} << Sep{} << dst;
+        str << Ins<I>{} << Sz<S>{} << str.tab << Imu<S>{src} << Sep{} << dst;
     } else {
         str << Ins<I>{} << Sz<S>{} << str.tab << Ims<S>(src) << "," << dst;
     }
@@ -487,7 +487,7 @@ Moira::dasmAndiccr(StrWriter &str, u32 &addr, u16 op) const
     auto src = dasmIncRead<S>(addr);
 
     if (str.style.syntax == DASM_MUSASHI) {
-        str << Ins<I>{} << str.tab << Imu{src} << Sep{} << Ccr{};
+        str << Ins<I>{} << str.tab << Imu<S>{src} << Sep{} << Ccr{};
     } else {
         str << Ins<I>{} << Sz<S>{} << str.tab << Ims<S>(src) << Sep{} << Ccr{};
     }
@@ -515,11 +515,14 @@ Moira::dasmBitFieldDn(StrWriter &str, u32 &addr, u16 op) const
     auto w   = ___________xxxxx(ext);
 
     // Catch illegal extension words
-    if ((str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) && !isValidExt(I, M, op, ext)) {
+    if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        addr = old;
-        dasmIllegal<I, M, S>(str, addr, op);
-        return;
+        if (!isValidExt(I, M, op, ext)) {
+
+            addr = old;
+            dasmIllegal<I, M, S>(str, addr, op);
+            return;
+        }
     }
 
     str << Ins<I>{} << str.tab;
@@ -629,11 +632,14 @@ Moira::dasmCas(StrWriter &str, u32 &addr, u16 op) const
     auto dst = Op <M,S> ( _____________xxx(op), addr );
 
     // Catch illegal extension words
-    if ((str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) && !isValidExt(I, M, op, ext)) {
+    if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        addr = old;
-        dasmIllegal<I, M, S>(str, addr, op);
-        return;
+        if (!isValidExt(I, M, op, ext)) {
+
+            addr = old;
+            dasmIllegal<I, M, S>(str, addr, op);
+            return;
+        }
     }
 
     str << Ins<I>{} << Sz<S>{} << str.tab << dc << Sep{} << du << Sep{} << dst;
@@ -653,11 +659,14 @@ Moira::dasmCas2(StrWriter &str, u32 &addr, u16 op) const
     auto rn2 = Rn ( (ext >> 12) & 0b1111 );
 
     // Catch illegal extension words (binutils only checks the first word)
-    if ((str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) && !isValidExt(I, M, op, u16(ext >> 16))) {
+    if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        addr = old;
-        dasmIllegal<I, M, S>(str, addr, op);
-        return;
+        if (!isValidExt(I, M, op, u16(ext >> 16))) {
+
+            addr = old;
+            dasmIllegal<I, M, S>(str, addr, op);
+            return;
+        }
     }
 
     auto fill = str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT ? ',' : ':';
@@ -711,11 +720,14 @@ Moira::dasmChkCmp2(StrWriter &str, u32 &addr, u16 op) const
     auto dst = Rn       ( xxxx____________(ext)      );
 
     // Catch illegal extension words
-    if ((str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) && !isValidExt(I, M, op, ext)) {
+    if (str.style.syntax == DASM_GNU || str.style.syntax == DASM_GNU_MIT) {
 
-        addr = old;
-        dasmIllegal<I, M, S>(str, addr, op);
-        return;
+        if (!isValidExt(I, M, op, ext)) {
+            
+            addr = old;
+            dasmIllegal<I, M, S>(str, addr, op);
+            return;
+        }
     }
 
     if (ext & 0x0800) {
@@ -1059,7 +1071,7 @@ Moira::dasmBitImDy(StrWriter &str, u32 &addr, u16 op) const
 
         default:
 
-            str << Ins<I>{} << str.tab << Imu(src) << Sep{} << dst;
+            str << Ins<I>{} << str.tab << Imu<S>(src) << Sep{} << dst;
     }
 }
 
@@ -1079,7 +1091,7 @@ Moira::dasmBitImEa(StrWriter &str, u32 &addr, u16 op) const
 
         default:
 
-            str << Ins<I>{} << str.tab << Imu(src) << Sep{} << dst;
+            str << Ins<I>{} << str.tab << Imu<S>(src) << Sep{} << dst;
     }
 }
 
diff --git a/Emulator/Components/CPU/Moira/MoiraDataflow.h b/Emulator/Components/CPU/Moira/MoiraDataflow.h
index af55c0f1f..9ca38d35a 100644
--- a/Emulator/Components/CPU/Moira/MoiraDataflow.h
+++ b/Emulator/Components/CPU/Moira/MoiraDataflow.h
@@ -63,6 +63,13 @@ template <Core C, Mode M, Size S, Flags F = 0> u32 computeEAfull(u32 an);
 template <Core C, Mode M, Size S = Word, Flags F = 0>
 void readOp(int n, u32 *ea, u32 *result);
 
+// Experimental
+template <Mode M, Flags F = 0> FpuExtended readFpuOp(int n, FltFormat fmt);
+template <Mode M, Flags F = 0> FpuExtended readFpuOpRg(int n, FltFormat fmt);
+template <Mode M, Flags F = 0> FpuExtended readFpuOpEa(int n, FltFormat fmt);
+template <Mode M, Flags F = 0> FpuExtended readFpuOpEa(int n, u32 ea, FltFormat fmt);
+template <Mode M, Flags F = 0> FpuExtended readFpuOpIm(FltFormat fmt);
+
 /* Writes an operand
  *
  * If parameter ea is omitted, the destination of the operand is determined
@@ -71,7 +78,10 @@ void readOp(int n, u32 *ea, u32 *result);
 template <Core C, Mode M, Size S, Flags F = 0> void writeOp(int n, u32 val);
 template <Core C, Mode M, Size S, Flags F = 0> void writeOp(int n, u32 ea, u32 val);
 
-// Emulates the address register modification for modes (An)+, (An)-
+template <Mode M, Flags F = 0> void writeFpuOp(int n, FPUReg &reg, FltFormat fmt, int k = 0);
+template <Mode M, Flags F = 0> void writeFpuOp(int n, u32 ea, FPUReg &reg, FltFormat fmt, int k = 0);
+
+// Emulates the address register modification for modes (An)+, (An)- (DEPRECATED)
 template <Mode M, Size S> void updateAn(int n);
 template <Mode M, Size S> void updateAnPI(int n);
 template <Mode M, Size S> void updateAnPD(int n);
@@ -79,6 +89,14 @@ template <Mode M, Size S> void undoAn(int n);
 template <Mode M, Size S> void undoAnPI(int n);
 template <Mode M, Size S> void undoAnPD(int n);
 
+// Emulates the address register modification for modes (An)+, (An)-
+void updateAn(Mode M, Size S, int n);
+void updateAnPI(Mode M, Size S, int n);
+void updateAnPD(Mode M, Size S, int n);
+void undoAn(Mode M, Size S, int n);
+void undoAnPI(Mode M, Size S, int n);
+void undoAnPD(Mode M, Size S, int n);
+
 // Reads a value from program or data space, depending on the addressing mode
 template <Core C, Mode M, Size S, Flags F = 0> u32 readM(u32 addr);
 
diff --git a/Emulator/Components/CPU/Moira/MoiraDataflow_cpp.h b/Emulator/Components/CPU/Moira/MoiraDataflow_cpp.h
index 681bf9cae..634f79ee1 100644
--- a/Emulator/Components/CPU/Moira/MoiraDataflow_cpp.h
+++ b/Emulator/Components/CPU/Moira/MoiraDataflow_cpp.h
@@ -228,6 +228,215 @@ Moira::readOp(int n, u32 *ea, u32 *result)
     }
 }
 
+template <Mode M, Flags F> FpuExtended
+Moira::readFpuOp(int n, FltFormat fmt)
+{
+    FpuExtended result;
+
+    if constexpr (M == MODE_DN) return readFpuOpRg<M, F>(n, fmt);
+    if constexpr (M == MODE_IM) return readFpuOpIm<M, F>(fmt);
+
+    return readFpuOpEa<M>(n, fmt);
+}
+
+template <Mode M, Flags F> FpuExtended
+Moira::readFpuOpRg(int n, FltFormat fmt)
+{
+    FpuExtended result;
+
+    switch (fmt) {
+
+        case FLT_BYTE:
+        {
+            auto data = FpuByte(reg.d[n]);
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        case FLT_WORD:
+        {
+            auto data = FpuWord(reg.d[n]);
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        case FLT_LONG:
+        {
+            auto data = FpuLong(reg.d[n]);
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        case FLT_SINGLE:
+        {
+            auto data = FpuSingle(reg.d[n]);
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        default:
+
+            // Invalid FPU format
+            throw IllegalInstruction();
+    }
+
+    return result;
+}
+
+template <Mode M, Flags F> FpuExtended
+Moira::readFpuOpIm(FltFormat fmt)
+{
+    FpuExtended result;
+
+    switch (fmt) {
+
+        case FLT_LONG:
+        {
+            auto data = FpuLong(readExt<C68020, Long>());
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        case FLT_SINGLE:
+        {
+            auto data = FpuSingle(readExt<C68020, Long>());
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        case FLT_EXTENDED:
+        {
+            u32 high = readExt<C68020, Word>();
+            (void)readExt<C68020, Word>();
+            u64 low = (u64)readExt<C68020, Long>() << 32;
+            low |= readExt<C68020, Long>();
+
+            result = FpuExtended(high, low);
+            result.normalize();
+            break;
+        }
+        case FLT_PACKED:
+        {
+            auto data = FpuPacked(readExt<C68020, Long>(),
+                                  readExt<C68020, Long>(),
+                                  readExt<C68020, Long>());
+            result = FpuExtended(data, fpu.getRoundingMode());
+            break;
+        }
+        case FLT_WORD:
+        {
+            auto data = FpuWord(readExt<C68020, Word>());
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        case FLT_DOUBLE:
+        {
+            auto data = FpuDouble(readExt<C68020, Long>(),
+                                  readExt<C68020, Long>());
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        case FLT_BYTE:
+        {
+            auto data = FpuByte(readExt<C68020, Byte>());
+            result = FpuExtended(data, fpu.exceptionHandler);
+            break;
+        }
+        default:
+            fatalError;
+    }
+
+    return result;
+}
+
+template <Mode M, Flags F> FpuExtended
+Moira::readFpuOpEa(int n, FltFormat fmt)
+{
+    u32 ea;
+
+    switch (fmt) {
+
+        case FLT_BYTE:      ea = computeEA<C68020, M, Byte>(n); break;
+        case FLT_WORD:      ea = computeEA<C68020, M, Word>(n); break;
+        case FLT_LONG:      ea = computeEA<C68020, M, Long>(n); break;
+        case FLT_SINGLE:    ea = computeEA<C68020, M, Long>(n); break;
+        case FLT_DOUBLE:    ea = computeEA<C68020, M, Quad>(n); break;
+        case FLT_EXTENDED:  ea = computeEA<C68020, M, Extended>(n); break;
+        case FLT_PACKED:    ea = computeEA<C68020, M, Quad>(n); break;
+
+        default:
+            fatalError;
+    }
+
+    return readFpuOpEa<M,F>(n, ea, fmt);
+}
+
+template <Mode M, Flags F> FpuExtended
+Moira::readFpuOpEa(int n, u32 ea, FltFormat fmt)
+{
+    FpuExtended result;
+
+    switch (fmt) {
+
+        case FLT_BYTE:
+        {
+            auto data = FpuByte(readM<C68020, M, Byte>(ea));
+            updateAn<M, Byte>(n);
+
+            result = FpuExtended(data);
+            break;
+        }
+        case FLT_WORD:
+        {
+            auto data = FpuWord(readM<C68020, M, Word>(ea));
+            updateAn<M, Word>(n);
+
+            result = FpuExtended(data);
+            break;
+        }
+        case FLT_LONG:
+        {
+            auto data = FpuLong(readM<C68020, M, Long>(ea));
+            updateAn<M, Long>(n);
+            
+            result = FpuExtended(data);
+            break;
+        }
+        case FLT_SINGLE:
+        {
+            auto data = FpuSingle(readM<C68020, M, Long>(ea));
+            updateAn<M, Long>(n);
+
+            result = FpuExtended(data);
+            break;
+        }
+        case FLT_DOUBLE:
+        {
+            auto data = FpuDouble(readM<C68020, M, Long>(ea),
+                                  readM<C68020, M, Long>(U32_ADD(ea, 4)));
+            updateAn<M, Quad>(n);
+
+            result = FpuExtended(data);
+            break;
+        }
+        case FLT_EXTENDED:
+        {
+            result = FpuExtended(readM<C68020, M, Word>(ea),
+                                 readM<C68020, M, Long>(U32_ADD(ea, 4)),
+                                 readM<C68020, M, Long>(U32_ADD(ea, 8)));
+            result.normalize();
+            updateAn<M, Extended>(n);
+            break;
+        }
+        case FLT_PACKED:
+        {
+            auto data = FpuPacked(readM<C68020, M, Long>(ea),
+                                  readM<C68020, M, Long>(U32_ADD(ea, 4)),
+                                  readM<C68020, M, Long>(U32_ADD(ea, 8)));
+            updateAn<M, Extended>(n);
+            result = FpuExtended(data, fpu.getRoundingMode());
+            break;
+        }
+        default:
+            fatalError;
+    }
+    return result;
+}
+
 template <Core C, Mode M, Size S, Flags F> void
 Moira::writeOp(int n, u32 val)
 {
@@ -273,6 +482,142 @@ Moira::writeOp(int n, u32 ea, u32 val)
     }
 }
 
+template <Mode M, Flags F> void
+Moira::writeFpuOp(int n, FPUReg &reg, FltFormat fmt, int k)
+{
+    u32 ea;
+
+    switch (fmt) {
+
+        case FLT_BYTE:      ea = computeEA<C68020, M, Byte>(n); break;
+        case FLT_WORD:      ea = computeEA<C68020, M, Word>(n); break;
+        case FLT_LONG:      ea = computeEA<C68020, M, Long>(n); break;
+        case FLT_SINGLE:    ea = computeEA<C68020, M, Long>(n); break;
+        case FLT_DOUBLE:    ea = computeEA<C68020, M, Quad>(n); break;
+        case FLT_EXTENDED:  ea = computeEA<C68020, M, Extended>(n); break;
+        case FLT_PACKED:    ea = computeEA<C68020, M, Quad>(n); break;
+
+        default:
+            fatalError;
+    }
+
+    writeFpuOp<M,F>(n, ea, reg, fmt, k);
+}
+
+template <Mode M, Flags F> void
+Moira::writeFpuOp(int n, u32 ea, FPUReg &reg, FltFormat fmt, int k)
+{
+    auto exceptionHandler = [this](int flags) { fpu.setExcStatusBit(flags); };
+
+    switch (fmt) {
+
+        case FLT_BYTE:
+        {
+            auto data = FpuByte(reg, exceptionHandler).raw;
+            writeM<C68020, M, Byte>(ea, data);
+            updateAn<M, Byte>(n);
+            break;
+        }
+        case FLT_WORD:
+        {
+            auto data = FpuWord(reg, exceptionHandler).raw;
+            writeM<C68020, M, Word>(ea, data);
+            updateAn<M, Word>(n);
+            break;
+        }
+        case FLT_LONG:
+        {
+            auto data = FpuLong(reg, exceptionHandler).raw;
+            writeM<C68020, M, Long>(ea, data);
+            updateAn<M, Long>(n);
+            break;
+        }
+        case FLT_SINGLE:
+        {
+            auto data = FpuSingle(reg, exceptionHandler).raw;
+            writeM<C68020, M, Long>(ea, data);
+            updateAn<M, Long>(n);
+            break;
+        }
+        case FLT_DOUBLE:
+        {
+            auto data = FpuDouble(reg, exceptionHandler).raw;
+            writeM<C68020, M, Long>(ea, u32(data >> 32));
+            writeM<C68020, M, Long>(U32_ADD(ea, Long), u32(data));
+            updateAn<M, Quad>(n);
+            break;
+        }
+        case FLT_EXTENDED:
+        {
+            FpuExtended data;
+
+            if constexpr (F & FPU_FMOVEM) {
+                data = reg.val;
+            } else {
+                data = reg.round();
+            }
+
+            writeM<C68020, M, Word>(ea, u32(data.raw.high));
+            writeM<C68020, M, Word>(U32_ADD(ea, 2), u32(0));
+            writeM<C68020, M, Long>(U32_ADD(ea, 4), u32(data.raw.low >> 32));
+            writeM<C68020, M, Long>(U32_ADD(ea, 8), u32(data.raw.low));
+            updateAn<M, Extended>(n);
+            break;
+        }
+        case FLT_PACKED:
+        {
+            auto data = FpuPacked(reg, k, fpu.getRoundingMode(), exceptionHandler);
+            auto ea = computeEA<C68020, M, Extended>(n);
+            writeM<C68020, M, Long>(ea, data.data[0]);
+            writeM<C68020, M, Long>(U32_ADD(ea, 4), data.data[1]);
+            writeM<C68020, M, Long>(U32_ADD(ea, 8), data.data[2]);
+            updateAn<M, Extended>(n);
+            break;
+        }
+
+        default:
+            fatalError;
+    }
+}
+
+void
+Moira::updateAn(Mode M, Size S, int n)
+{
+    if (M == 3) U32_INC(reg.a[n], (n == 7 && S == Byte) ? 2 : S);
+    if (M == 4) U32_DEC(reg.a[n], (n == 7 && S == Byte) ? 2 : S);
+}
+
+void
+Moira::updateAnPI(Mode M, Size S, int n)
+{
+    if (M == 3) U32_INC(reg.a[n], (n == 7 && S == Byte) ? 2 : S);
+}
+
+void
+Moira::updateAnPD(Mode M, Size S, int n)
+{
+    if (M == 4) U32_DEC(reg.a[n], (n == 7 && S == Byte) ? 2 : S);
+}
+
+void
+Moira::undoAn(Mode M, Size S, int n)
+{
+    if (M == 3) U32_DEC(reg.a[n], (n == 7 && S == Byte) ? 2 : S);
+    if (M == 4) U32_INC(reg.a[n], (n == 7 && S == Byte) ? 2 : S);
+}
+
+void
+Moira::undoAnPI(Mode M, Size S, int n)
+{
+    if (M == 3) U32_DEC(reg.a[n], (n == 7 && S == Byte) ? 2 : S);
+}
+
+void
+Moira::undoAnPD(Mode M, Size S, int n)
+{
+    if (M == 4) U32_INC(reg.a[n], (n == 7 && S == Byte) ? 2 : S);
+}
+
 template <Mode M, Size S> void
 Moira::updateAn(int n)
 {
diff --git a/Emulator/Components/CPU/Moira/MoiraDebugger.cpp b/Emulator/Components/CPU/Moira/MoiraDebugger.cpp
index 6fc478408..b14d036b3 100644
--- a/Emulator/Components/CPU/Moira/MoiraDebugger.cpp
+++ b/Emulator/Components/CPU/Moira/MoiraDebugger.cpp
@@ -2,9 +2,7 @@
 // This file is part of Moira - A Motorola 68k emulator
 //
 // Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
-// Licensed under the GNU General Public License v3
-//
-// See https://www.gnu.org for license information
+// Published under the terms of the MIT License
 // -----------------------------------------------------------------------------
 
 #include "config.h"
diff --git a/Emulator/Components/CPU/Moira/MoiraDebugger.h b/Emulator/Components/CPU/Moira/MoiraDebugger.h
index 0a4d96374..5b425865b 100644
--- a/Emulator/Components/CPU/Moira/MoiraDebugger.h
+++ b/Emulator/Components/CPU/Moira/MoiraDebugger.h
@@ -2,9 +2,7 @@
 // This file is part of Moira - A Motorola 68k emulator
 //
 // Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
-// Licensed under the GNU General Public License v3
-//
-// See https://www.gnu.org for license information
+// Published under the terms of the MIT License
 // -----------------------------------------------------------------------------
 
 #pragma once
diff --git a/Emulator/Components/CPU/Moira/MoiraExceptions_cpp.h b/Emulator/Components/CPU/Moira/MoiraExceptions_cpp.h
index 5bfc170c4..51c704855 100644
--- a/Emulator/Components/CPU/Moira/MoiraExceptions_cpp.h
+++ b/Emulator/Components/CPU/Moira/MoiraExceptions_cpp.h
@@ -321,6 +321,9 @@ Moira::execException(ExceptionType exc, int nr)
 template <Core C> void
 Moira::execException(ExceptionType exc, int nr)
 {
+    // printf("Moira::execException(%d, %d)\n", exc, nr);
+    // if (exc == 11) debugger.stepInto();
+
     u16 status = getSR();
 
     // Determine the exception vector number
diff --git a/Emulator/Components/CPU/Moira/MoiraExecFPU_cpp.h b/Emulator/Components/CPU/Moira/MoiraExecFPU_cpp.h
index cbe028aa5..237df8e0c 100644
--- a/Emulator/Components/CPU/Moira/MoiraExecFPU_cpp.h
+++ b/Emulator/Components/CPU/Moira/MoiraExecFPU_cpp.h
@@ -5,163 +5,867 @@
 // Published under the terms of the MIT License
 // -----------------------------------------------------------------------------
 
-bool
-Moira::isValidExtFPU(Instr I, Mode M, u16 op, u32 ext) const
+template <Core C, Instr I, Mode M, Size S> void
+Moira::execFBcc(u16 opcode)
 {
-    auto cod  = xxx_____________ (ext);
-    auto mode = ___xx___________ (ext);
-    auto fmt  = ___xxx__________ (ext);
-    auto lst  = ___xxx__________ (ext);
-    auto cmd  = _________xxxxxxx (ext);
+    AVAILABILITY(C68000)
+    fpu.resetState = false;
 
-    switch (I) {
+    auto cnd = ___________xxxxx (opcode);
+    u32 oldpc = reg.pc;
+            
+    if (fpu.cpcc(cnd)) {
 
-        case FDBcc:
-        case FScc:
-        case FTRAPcc:
+        u32 disp = queue.irc;
 
-            return (ext & 0xFFE0) == 0;
+        if (S == Long) {
 
-        case FMOVECR:
+            readExt<C>();
+            disp = disp << 16 | queue.irc;
+        }
 
-            return (op & 0x3F) == 0;
+        u32 newpc = U32_ADD(oldpc, SEXT<S>(disp));
 
-        case FMOVE:
+        // Check for address error
+        if (misaligned<C>(newpc)) {
+            throw AddressError(makeFrame(newpc));
+        }
 
-            switch (cod) {
+        // Take branch
+        reg.pc = newpc;
+        fullPrefetch<C, POLL>();
 
-                case 0b010:
+    } else {
 
-                    if (M == MODE_IP) break;
-                    return true;
+        // Fall through to next instruction
+        readExt<C>();
+        if constexpr (S == Long) readExt<C>();
+        prefetch<C>();
+    }
+    
+    FINALIZE
+}
 
-                case 0b000:
+template <Core C, Instr I, Mode M, Size S> void
+Moira::execFDbcc(u16 opcode)
+{
+    AVAILABILITY(C68000)
+    fpu.resetState = false;
 
-                    if (cmd == 0 && cod == 0 && (op & 0x3F)) break;
-                    return true;
+    auto ext = readExt<C,Word>();
+    auto cnd = ___________xxxxx (ext);
 
-                case 0b011:
+    if (!fpu.cpcc(cnd)) {
 
-                    if (fmt != 0b011 && fmt != 0b111 && (ext & 0x7F)) break;
+        int dn = _____________xxx(opcode);
+        u32 newpc = U32_ADD(reg.pc, (i16)queue.irc);
 
-                    if (M == MODE_DN) {
-                        if (fmt == 0b010 || fmt == 0b011 || fmt == 0b101 || fmt == 0b111) break;
-                    }
-                    if (M == MODE_AN) {
-                        if (fmt == 0b011 || fmt == 0b111) break;
-                    }
-                    if (M == MODE_DIPC || M == MODE_IXPC || M == MODE_IM || M == MODE_IP) {
-                        break;
-                    } else {
-                        if (fmt == 0b111 && (ext & 0xF)) break;
-                    }
+        bool takeBranch = readD<Word>(dn) != 0;
 
-                    return true;
-            }
+        // Check for address error
+        if (misaligned<C, S>(newpc)) {
+            throw AddressError(makeFrame<AE_INC_PC>(newpc, newpc));
+        }
 
-        case FMOVEM:
+        // Decrement loop counter
+        writeD<Word>(dn, U32_SUB(readD<Word>(dn), 1));
 
-            switch (cod) {
+        // Branch
+        if (takeBranch) {
+            
+            reg.pc = newpc;
+            fullPrefetch<C, POLL>();
 
-                case 0b101:
-                {
+        } else {
 
-                    if (ext & 0x3FF) break;
+            (void)read<C, MEM_PROG, Word>(reg.pc + 2);
+            reg.pc += 2;
+            fullPrefetch<C, POLL>();
+        }
 
-                    if (M == MODE_DN || M == MODE_AN) {
-                        if (lst != 0b000 && lst != 0b001 && lst != 0b010 && lst != 0b100) break;
-                    }
-                    if (M == MODE_DIPC || M == MODE_IXPC || M == MODE_IM || M == MODE_IP) {
-                        break;
-                    }
-                    return true;
-                }
-                case 0b100:
+    } else {
 
-                    if (ext & 0x3FF) break;
-                    if (M == MODE_IP) break;
-                    return true;
+        // Fall through to next instruction
+        reg.pc += 2;
+        fullPrefetch<C, POLL>();
+    }
+    
+    FINALIZE
+}
 
-                case 0b110:
-                case 0b111:
+template <Core C, Instr I, Mode M, Size S> void
+Moira::execFGen(u16 opcode)
+{
+    AVAILABILITY(C68000)
+    fpu.resetState = false;
 
-                    if (ext & 0x0700) break;
-                    if (mode == 3 && (ext & 0x8F)) break;
+    auto ext = queue.irc;
+    auto cod  = xxx_____________(ext);
+    auto cmd  = _________xxxxxxx(ext);
 
-                    if (M == MODE_DN || M == MODE_AN) {
-                        break;
-                    }
-                    if (M == MODE_DIPC || M == MODE_IXPC || M == MODE_IM || M == MODE_IP) {
-                        break;
-                    }
-                    if (M == MODE_AI) {
-                        if (mode == 0 || mode == 1) break;
-                    }
-                    if (M == MODE_PI) {
-                        if (mode == 0 || mode == 1 || cod == 0b111) break;
-                    }
-                    if (M == MODE_PD) {
-                        if (cod == 0b110) break;
-                        if (cod == 0b111 && (mode == 1) && (ext & 0x8F)) break;
-                        if (cod == 0b111 && (mode == 2 || mode == 3)) break;
-                    }
-                    if (M == MODE_DI || M == MODE_IX || M == MODE_AW || M == MODE_AL) {
-                        if (mode == 0 || mode == 1) break;
-                    }
-                    return true;
-            }
-            return false;
+    if (M == MODE_AN) {
+        if (ext & 0x4000) { execLineF<C, I, M, S>(opcode); return; }
+    }
+    if (M == MODE_IP) {
+        if (cod == 0b010) { execLineF<C, I, M, S>(opcode); return; }
+    }
 
-        default:
-            fatalError;
+    // Catch FMOVE instructions
+    switch (cod) {
+
+        case 0b010:
+
+            if ((ext & 0xFC00) == 0x5C00) { execFMovecr<C, FMOVECR, M, S>(opcode); return; }
+            [[fallthrough]];
+
+        case 0b000:
+
+            if (cmd != 0x00 && cmd != 0x40 && cmd != 0x44) break;
+            [[fallthrough]];
+
+        case 0b011:
+
+            execFMove<C, FMOVE, M, S>(opcode);
+            return;
+
+        case 0b101:
+        case 0b100:
+        case 0b110:
+        case 0b111:
+
+            execFMovem<C, FMOVEM, M, S>(opcode);
+            return;
     }
+
+    // Catch all other instructions
+    switch (cod) {
+
+        case 0b010:
+        case 0b000:
+
+            switch (cmd) {
+
+                case 0x01: execFGeneric<C, FINT, M, S>(opcode); return;
+                case 0x02: execFGeneric<C, FSINH, M, S>(opcode); return;
+                case 0x03: execFGeneric<C, FINTRZ, M, S>(opcode); return;
+                case 0x04: execFGeneric<C, FSQRT, M, S>(opcode); return;
+                case 0x06: execFGeneric<C, FLOGNP1, M, S>(opcode); return;
+                case 0x08: execFGeneric<C, FETOXM1, M, S>(opcode); return;
+                case 0x09: execFGeneric<C, FTANH, M, S>(opcode); return;
+                case 0x0A: execFGeneric<C, FATAN, M, S>(opcode); return;
+                case 0x0C: execFGeneric<C, FASIN, M, S>(opcode); return;
+                case 0x0D: execFGeneric<C, FATANH, M, S>(opcode); return;
+                case 0x0E: execFGeneric<C, FSIN, M, S>(opcode); return;
+                case 0x0F: execFGeneric<C, FTAN, M, S>(opcode); return;
+                case 0x10: execFGeneric<C, FETOX, M, S>(opcode); return;
+                case 0x11: execFGeneric<C, FTWOTOX, M, S>(opcode); return;
+                case 0x12: execFGeneric<C, FTENTOX, M, S>(opcode); return;
+                case 0x14: execFGeneric<C, FLOGN, M, S>(opcode); return;
+                case 0x15: execFGeneric<C, FLOG10, M, S>(opcode); return;
+                case 0x16: execFGeneric<C, FLOG2, M, S>(opcode); return;
+                case 0x18: execFGeneric<C, FABS, M, S>(opcode); return;
+                case 0x19: execFGeneric<C, FCOSH, M, S>(opcode); return;
+                case 0x1A: execFGeneric<C, FNEG, M, S>(opcode); return;
+                case 0x1C: execFGeneric<C, FACOS, M, S>(opcode); return;
+                case 0x1D: execFGeneric<C, FCOS, M, S>(opcode); return;
+                case 0x1E: execFGeneric<C, FGETEXP, M, S>(opcode); return;
+                case 0x1F: execFGeneric<C, FGETMAN, M, S>(opcode); return;
+                case 0x20: execFGeneric<C, FDIV, M, S>(opcode); return;
+                case 0x21: execFGeneric<C, FMOD, M, S>(opcode); return;
+                case 0x22: execFGeneric<C, FADD, M, S>(opcode); return;
+                case 0x23: execFGeneric<C, FMUL, M, S>(opcode); return;
+                case 0x24: execFGeneric<C, FSGLDIV, M, S>(opcode); return;
+                case 0x25: execFGeneric<C, FREM, M, S>(opcode); return;
+                case 0x26: execFGeneric<C, FSCAL, M, S>(opcode); return;
+                case 0x27: printf("TODO: FSGLMUL\n"); execFGeneric<C, FSGLMUL, M, S>(opcode); return;
+                case 0x28: execFGeneric<C, FSUB, M, S>(opcode); return;
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37: execFGeneric<C, FSINCOS, M, S>(opcode); return;
+                case 0x38: execFGeneric<C, FCMP, M, S>(opcode); return;
+                case 0x3A: execFGeneric<C, FTST, M, S>(opcode); return;
+                case 0x41: printf("TODO: FSSQRT\n"); execFGeneric<C, FSSQRT, M, S>(opcode); return;
+                case 0x45: printf("TODO: FDSQRT\n"); execFGeneric<C, FDSQRT, M, S>(opcode); return;
+                case 0x58: printf("TODO: FSABS\n"); execFGeneric<C, FSABS, M, S>(opcode); return;
+                case 0x5A: printf("TODO: FSNEG\n"); execFGeneric<C, FSNEG, M, S>(opcode); return;
+                case 0x5C: printf("TODO: FDABS\n"); execFGeneric<C, FDABS, M, S>(opcode); return;
+                case 0x5E: printf("TODO: FDNEG\n"); execFGeneric<C, FDNEG, M, S>(opcode); return;
+                case 0x60: printf("TODO: FSDIV\n"); execFGeneric<C, FSDIV, M, S>(opcode); return;
+                case 0x62: printf("TODO: FSADD\n"); execFGeneric<C, FSADD, M, S>(opcode); return;
+                case 0x63: printf("TODO: FSMUL\n"); execFGeneric<C, FSMUL, M, S>(opcode); return;
+                case 0x64: printf("TODO: FDDIV\n"); execFGeneric<C, FDDIV, M, S>(opcode); return;
+                case 0x66: printf("TODO: FDADD\n"); execFGeneric<C, FDADD, M, S>(opcode); return;
+                case 0x67: printf("TODO: FDMUL\n"); execFGeneric<C, FDMUL, M, S>(opcode); return;
+                case 0x68: printf("TODO: FSSUB\n"); execFGeneric<C, FSSUB, M, S>(opcode); return;
+                case 0x6C: printf("TODO: FDSUB\n"); execFGeneric<C, FDSUB, M, S>(opcode); return;
+            }
+            break;
+    }
+
+    execLineF<C, I, M, S>(opcode);
+
+    FINALIZE
 }
 
 template <Core C, Instr I, Mode M, Size S> void
-Moira::execFBcc(u16 opcode)
+Moira::execFNop(u16 opcode)
 {
-    execLineF<C, I, M, S>(opcode);
+    AVAILABILITY(C68000)
+    fpu.resetState = false;
+
+    prefetch<C>();
+
+    FINALIZE
 }
 
 template <Core C, Instr I, Mode M, Size S> void
-Moira::execFDbcc(u16 opcode)
+Moira::execFRestore(u16 opcode)
 {
-    execLineF<C, I, M, S>(opcode);
+    AVAILABILITY(C68000);
+    fpu.resetState = false;
+
+    auto n   = _____________xxx (opcode);
+
+    auto ea = computeEA<C68020, M, S>(n);
+    auto fmtWord = readM<C, M, Long>(ea);
+    auto type = fpu.typeOfFrame(fmtWord);
+
+    switch (type) {
+
+        case FPU_FRAME_NULL:
+
+            fpu.reset();
+            break;
+
+        default:
+            
+            break;
+    }
+
+    updateAn(M, Size(fpu.stateFrameSize(type) + 4), n);
+    prefetch<C>();
+    FINALIZE
 }
 
 template <Core C, Instr I, Mode M, Size S> void
-Moira::execFGen(u16 opcode)
+Moira::execFSave(u16 opcode)
 {
-    execLineF<C, I, M, S>(opcode);
+    AVAILABILITY(C68000);
+
+    auto rg = _____________xxx (opcode);
+    auto ea = computeEA<C68020, M, Long>(rg);
+
+    // Depending on the current state, the FPU creates different frame types
+    FpuFrameType type = fpu.inResetState() ? FPU_FRAME_NULL : FPU_FRAME_IDLE;
+    auto size = fpu.stateFrameSize(type);
+
+    switch (type) {
+            
+        case FPU_FRAME_NULL:
+
+            writeM<C68020, M, Long>(ea, fpu.computeFormatWord(FPU_FRAME_NULL));
+            updateAn(M, Long, rg);
+            break;
+            
+        case FPU_FRAME_IDLE:
+                        
+            if (M == MODE_PD) {
+                
+                updateAn(M, Size(size + 4), rg);
+
+                writeM<C68020, M, Long>(ea, 0x70000000);
+                ea -= 4;
+                for (isize i = 0; i < (size / 4) - 1; i++) {
+                    writeM<C68020, M, Long>(ea, 0x0);
+                    ea -= 4;
+                }
+                writeM<C68020, M, Long>(ea, fpu.computeFormatWord(FPU_FRAME_IDLE));
+                
+            } else {
+             
+                writeM<C68020, M, Long>(ea, fpu.computeFormatWord(FPU_FRAME_IDLE));
+                ea += 4;
+                for (isize i = 0; i < (size / 4) - 1; i++) {
+                    writeM<C68020, M, Long>(ea, 0x0);
+                    ea += 4;
+                }
+                writeM<C68020, M, Long>(ea, 0x70000000);
+            }
+            break;
+            
+        default:
+            fatalError;
+    }
+            
+    prefetch<C>();
+    FINALIZE
 }
 
 template <Core C, Instr I, Mode M, Size S> void
-Moira::execFNop(u16 opcode)
+Moira::execFScc(u16 opcode)
 {
-    execLineF<C, I, M, S>(opcode);
+    AVAILABILITY(C68000);
+    fpu.resetState = false;
+
+    auto ext = readExt<C, Word>();
+    auto reg = _____________xxx (opcode);
+    auto cnd = ___________xxxxx (ext);
+
+    auto ea = computeEA<C68020, M, Byte>(reg);
+    auto data = fpu.cpcc(cnd) ? 0xFF : 0x00;
+    writeM<C68020, M, Byte>(ea, data);
+    updateAn<M, Byte>(reg);
+    prefetch<C>();
+
+    FINALIZE
 }
 
 template <Core C, Instr I, Mode M, Size S> void
-Moira::execFRestore(u16 opcode)
+Moira::execFTrapcc(u16 opcode)
 {
-    execLineF<C, I, M, S>(opcode);
+    AVAILABILITY(C68000)
+    fpu.resetState = false;
+
+    auto mod = _____________xxx (opcode);
+    auto cnd = ___________xxxxx (queue.irc);
+                    
+    if (mod == 0b010) { readExt<C, Word>(); }
+    if (mod == 0b011) { readExt<C, Long>(); }
+
+    if (fpu.cpcc(cnd)) {
+
+        // Execute exception handler
+        readExt<C>();
+        execException<C>(EXC_TRAPV);
+
+    } else {
+
+        // Fall through to next instruction
+        readExt<C>();
+        prefetch<C>();
+    }
+    
+    FINALIZE
 }
 
 template <Core C, Instr I, Mode M, Size S> void
-Moira::execFSave(u16 opcode)
+Moira::execFMove(u16 opcode)
 {
-    execLineF<C, I, M, S>(opcode);
+    AVAILABILITY(C68000);
+    fpu.resetState = false;
+
+    auto ext = readExt<C, Word>();
+    auto reg = _____________xxx (opcode);
+    auto cod = xxx_____________ (ext);
+    auto src = ___xxx__________ (ext);
+    auto dst = ______xxx_______ (ext);
+    auto fac = _________xxxxxxx (ext);
+
+    try {
+
+        // Catch illegal extension words
+        if (!fpu.isValidExt(I, M, opcode, ext)) throw IllegalInstruction();
+        /*
+        if (!fpu.isValidExt(I, M, opcode, ext)) {
+
+            execLineF<C, I, M, S>(opcode);
+            return;
+        }
+        */
+
+        // Clear the status register
+        fpu.clearExcStatusByte();
+
+        switch (cod) {
+
+            case 0b000:                                 // FMOVE FpFp
+
+                fpu.fpr[dst].load(fpu.fpr[src].val);
+                fpu.setConditionCodes(dst);
+                break;
+
+            case 0b010:
+
+                if (M == MODE_IM) {                     // FMOVE ImFp
+
+                    if (src >= 0 && src <= 6) {
+
+                        auto value = readFpuOpIm<M>(FltFormat(src));
+
+                        if (auto nan = fpu.resolveNan(value); nan) {
+                            value = *nan;
+                        }
+                        fpu.fpr[dst].load(value);
+                    }
+
+                } else {                                // FMOVE EaFp
+
+                    auto value = readFpuOp<M>(reg, FltFormat(src));
+
+                    if (auto nan = fpu.resolveNan(value); nan) {
+                        value = *nan;
+                    }
+                    fpu.fpr[dst].load(value);
+                }
+
+                fpu.setConditionCodes(dst);
+                break;
+
+            case 0b011:                                 // FMOVE FpEa
+
+                if (src == 0b011 || src == 0b111) {     // P{#k} || P{Dn}
+
+                    // Get the k-factor, either directly or from a register
+                    int k = (src == 0b011) ? fac : readD(fac >> 4);
+
+                    // The k-factor is a sign-extended 7-bit value
+                    k = i8(k | (k & 0x40) << 1);
+
+                    writeFpuOp<M>(reg, fpu.fpr[dst], FLT_PACKED, k);
+                    break;
+                }
+
+                writeFpuOp<M>(reg, fpu.fpr[dst], FltFormat(src));
+                break;
+        }
+
+        prefetch<C>();
+
+        FINALIZE
+
+    } catch (IllegalInstruction &exc) {
+
+        execLineF<C, I, M, S>(opcode);
+    }
 }
 
 template <Core C, Instr I, Mode M, Size S> void
-Moira::execFScc(u16 opcode)
+Moira::execFMovecr(u16 opcode)
 {
-    execLineF<C, I, M, S>(opcode);
+    AVAILABILITY(C68000);
+    fpu.resetState = false;
+
+    auto ext = readExt<C,Word>();
+    auto dst = ______xxx_______ (ext);
+    auto ofs = _________xxxxxxx (ext);
+
+    // Catch illegal extension words
+    if (!fpu.isValidExt(I, M, opcode, ext)) {
+
+        execLineF<C, I, M, S>(opcode);
+        return;
+    }
+
+    // Clear the status register
+    fpu.clearExcStatusByte();
+
+    fpu.fpr[dst].load(fpu.readCR(ofs));
+    fpu.setConditionCodes(dst);
+
+    prefetch<C>();
+
+    FINALIZE
 }
 
 template <Core C, Instr I, Mode M, Size S> void
-Moira::execFTrapcc(u16 opcode)
+Moira::execFMovem(u16 opcode)
 {
-    execLineF<C, I, M, S>(opcode);
+    AVAILABILITY(C68000);
+    fpu.resetState = false;
+
+    auto ext = queue.irc;
+    auto reg = _____________xxx (opcode);
+    auto cod = xxx_____________ (ext);
+    auto mod = ___xx___________ (ext);
+    auto lll = ___xxx__________ (ext);
+
+    if (!MIMIC_MUSASHI) {
+
+        if (!fpu.isValidExt(I, M, opcode, ext)) {
+
+            execLineF<C, I, M, S>(opcode);
+            return;
+        }
+    }
+
+    auto oldfpsr = fpu.fpsr;    // TODO: IS THIS STILL NEEDED?
+
+    switch (cod) {              // FMOVEM Ea,CR
+
+        case 0b100:
+        {
+            (void)readExt<C,Word>();
+
+            u32 ea, data;
+
+            if (lll & 4) {      // -> FPCR
+
+                readOp<C, M, Long, STD_AE_FRAME>(reg, &ea, &data);
+                U32_INC(ea, 4);
+                fpu.setFPCR(data);
+            }
+            if (lll & 2) {      // -> FPSR
+
+                readOp<C, M, Long, STD_AE_FRAME>(reg, &ea, &data);
+                U32_INC(ea, 4);
+                fpu.setFPSR(data);
+                oldfpsr = fpu.getFPSR();
+            }
+            if (lll & 1) {      // -> FPIAR
+
+                readOp<C, M, Long, STD_AE_FRAME>(reg, &ea, &data);
+                U32_INC(ea, 4);
+                fpu.setFPIAR(data);
+            }
+            prefetch<C>();
+            break;
+        }
+        case 0b101:             // FMOVEM CR,Ea
+        {
+            (void)readExt<C,Word>();
+
+            if constexpr (M == MODE_PD) {
+
+                u32 data = 0;
+                auto ea = computeEA<C, M, Long>(reg);
+
+                if (lll & 1) {  // -> FPIAR
+
+                    data = fpu.getFPIAR();
+                    writeOp<C, M, Long>(reg, ea, data);
+                    updateAn<M, Long>(reg);
+                    U32_DEC(ea, 4);
+                }
+                if (lll & 2) {  // -> FPSR
+
+                    data = oldfpsr;
+                    writeOp<C, M, Long>(reg, ea, data);
+                    updateAn<M, Long>(reg);
+                    U32_DEC(ea, 4);
+                }
+                if (lll & 4) {  // -> FPCR
+
+                    data = fpu.getFPCR();
+                    writeOp<C, M, Long>(reg, ea, data);
+                    updateAn<M, Long>(reg);
+                    U32_DEC(ea, 4);
+                }
+
+            } else if constexpr (M != MODE_IM && M != MODE_IP) {
+
+                u32 data = 0;
+                auto ea = computeEA<C, M, Long>(reg);
+
+                if (lll & 4) {  // -> FPCR
+
+                    data = fpu.getFPCR();
+                    writeOp<C, M, Long>(reg, ea, data);
+                    updateAn<M, Long>(reg);
+                    U32_INC(ea, 4);
+                }
+                if (lll & 2) {  // -> FPSR
+
+                    data = oldfpsr;
+                    writeOp<C, M, Long>(reg, ea, data);
+                    updateAn<M, Long>(reg);
+                    U32_INC(ea, 4);
+                }
+                if (lll & 1) {  // -> FPIAR
+
+                    data = fpu.getFPIAR();
+                    writeOp<C, M, Long>(reg, ea, data);
+                    updateAn<M, Long>(reg);
+                    U32_INC(ea, 4);
+                }
+            }
+            prefetch<C>();
+            break;
+        }
+        case 0b110:             // FMOVEM Ea,Fp
+
+            fpu.clearExcStatusByte();
+
+            switch (mod) {
+
+                case 0b10:      // Static list, postincrement addressing
+                {
+                    auto reglist = ________xxxxxxxx (ext);
+                    (void)readExt<C,Word>();
+
+                    auto ea = computeEA<C, M, Extended>(reg);
+
+                    for (isize i = 0; i < 8; i++) {
+
+                        if (reglist & (0x80 >> i)) {
+
+                            auto val = readFpuOpEa<M>(reg, ea, FLT_EXTENDED);
+                            fpu.fpr[i].val = val;
+                            U32_INC(ea, 12);
+                        }
+                    }
+                    prefetch<C>();
+                    break;
+                }
+                case 0b11:      // Dynamic list, postincrement addressing
+                {
+                    auto reglist = getD(_________xxx____ (ext)) ;
+                    (void)readExt<C,Word>();
+
+                    auto ea = computeEA<C, M, Extended>(reg);
+
+                    for (isize i = 0; i < 8; i++) {
+
+                        if (reglist & (0x80 >> i)) {
+
+                            auto val = readFpuOpEa<M>(reg, ea, FLT_EXTENDED);
+                            fpu.fpr[i].val = val;
+                            U32_INC(ea, 12);
+                        }
+                    }
+                    prefetch<C>();
+                    break;
+                }
+                default:
+                    fatalError;
+            }
+            break;
+
+        case 0b111:             // FMOVEM Fp,Ea
+
+            fpu.clearExcStatusByte();
+
+            switch (mod) {
+
+                case 0b00:      // Static list, predecrement addressing
+                {
+                    auto reglist = ________xxxxxxxx (ext);
+                    (void)readExt<C,Word>();
+
+                    auto ea = computeEA<C, M, Extended>(reg);
+
+                    for (isize i = 8; i >= 0; i--) {
+
+                        if (reglist & (0x01 << i)) {
+
+                            writeFpuOp<M, FPU_FMOVEM>(reg, ea, fpu.fpr[i], FLT_EXTENDED);
+                            U32_DEC(ea, 12);
+                        }
+                    }
+                    prefetch<C>();
+                    break;
+                }
+                case 0b01:      // Dynamic list, predecrement addressing
+                {
+                    auto reglist = getD(_________xxx____ (ext)) ;
+                    (void)readExt<C,Word>();
+
+                    auto ea = computeEA<C, M, Extended>(reg);
+
+                    for (isize i = 8; i >= 0; i--) {
+
+                        if (reglist & (0x01 << i)) {
+
+                            writeFpuOp<M, FPU_FMOVEM>(reg, ea, fpu.fpr[i], FLT_EXTENDED);
+                            U32_DEC(ea, 12);
+                        }
+                    }
+                    prefetch<C>();
+                    break;
+                }
+                case 0b10:      // Static list, postincrement addressing
+                {
+                    auto reglist = ________xxxxxxxx (ext);
+                    (void)readExt<C,Word>();
+
+                    auto ea = computeEA<C, M, Extended>(reg);
+
+                    for (isize i = 0; i < 8; i++) {
+
+                        if (reglist & (0x80 >> i)) {
+
+                            writeFpuOp<M, FPU_FMOVEM>(reg, ea, fpu.fpr[i], FLT_EXTENDED);
+                            U32_INC(ea, 12);
+                        }
+                    }
+                    prefetch<C>();
+                    break;
+                }
+                case 0b11:      // Dynamic list, postincrement addressing
+
+                    auto reglist = getD(_________xxx____ (ext)) ;
+                    (void)readExt<C,Word>();
+
+                    auto ea = computeEA<C, M, Extended>(reg);
+
+                    for (isize i = 0; i < 8; i++) {
+
+                        if (reglist & (0x80 >> i)) {
+
+                            writeFpuOp<M, FPU_FMOVEM>(reg, ea, fpu.fpr[i], FLT_EXTENDED);
+                            U32_INC(ea, 12);
+                        }
+                    }
+                    prefetch<C>();
+                    break;
+            }
+            break;
+    }
+
+    fpu.fpsr = oldfpsr;
 }
 
+template <Core C, Instr I, Mode M, Size S> void
+Moira::execFGeneric(u16 opcode)
+{
+    AVAILABILITY(C68000);
+    fpu.resetState = false;
+
+    // Filter out unavailable instructions
+    if (!fpu.isSupported<I>()) {
+     
+        execLineF<C, I, M, S>(opcode);
+        FINALIZE
+        return;
+    }
+    
+    auto ext = queue.irc;
+    auto nr  = _____________xxx (opcode);
+    auto src = ___xxx__________ (ext);
+    auto dst = ______xxx_______ (ext);
+    
+    (void)readExt<C,Word>();
+
+    FpuExtended source, result;
+
+    if (ext & 0x4000) {
+        try {
+            source = readFpuOp<M>(nr, FltFormat(src));
+        } catch (...) {
+            execLineF<C, I, M, S>(opcode);
+            FINALIZE
+            return;
+        }
+    } else {
+        source = fpu.fpr[src].val;
+    }
+
+    fpu.clearExcStatusByte();
+
+    if (I == FSINCOS) {
+        
+        auto dst2 = _____________xxx (ext);
+        FpuExtended result2;
+        
+        if (auto nan = fpu.resolveNan(source); nan) {
+            
+            result2 = *nan;
+            result = *nan;
+            
+        } else {
+            
+            result2 = fpu.fcos(source);
+            result = fpu.fsin(source);
+        }
+        
+        prefetch<C>();
+        fpu.fpr[dst2].load(result2);
+        fpu.fpr[dst].load(result);
+        fpu.setConditionCodes(dst);
+        
+        FINALIZE
+        return;
+        
+    } else if (FPU::isMonadic<I>()) {
+        
+        if (auto nan = fpu.resolveNan(source); nan) {
+            
+            printf("FPU::isMonadic NAN resolved\n");
+            result = *nan;
+            
+        } else {
+
+            printf("FPU::isMonadic\n");
+
+            switch (I) {
+                    
+                case FABS:  result = fpu.fabs(source); break;
+                case FACOS: result = fpu.facos(source); break;
+                case FASIN: result = fpu.fasin(source); break;
+                case FATAN: result = fpu.fatan(source); break;
+                case FATANH: result = fpu.fatanh(source); break;
+                case FCOS: result = fpu.fcos(source); break;
+                case FCOSH: result = fpu.fcosh(source); break;
+                case FETOX: result = fpu.fetox(source); break;
+                case FETOXM1: result = fpu.fetoxm1(source); break;
+                case FGETEXP: result = fpu.fgetexp(source); break;
+                case FGETMAN: result = fpu.fgetman(source); break;
+                case FINT: result = fpu.fint(source); break;
+                case FINTRZ: result = fpu.fintrz(source); break;
+                case FLOG10: result = fpu.flog10(source); break;
+                case FLOG2: result = fpu.flog2(source); break;
+                case FLOGN: result = fpu.flogn(source); break;
+                case FLOGNP1: result = fpu.flognp1(source); break;
+                case FNEG:  result = fpu.fneg(source); break;
+                case FSIN:  result = fpu.fsin(source); break;
+                case FSINH:  result = fpu.fsinh(source); break;
+                case FSQRT:  result = fpu.fsqrt(source); break;
+                case FTAN:  result = fpu.ftan(source); break;
+                case FTANH:  result = fpu.ftanh(source); break;
+                case FTENTOX:  result = fpu.ftentox(source); break;
+                case FTST: result = fpu.ftst(source); break;
+                case FTWOTOX:  result = fpu.ftwotox(source); break;
+                    
+                default:
+                    result = source;
+                    break;
+            }
+        }
+
+    } else {
+        
+        auto dest = fpu.fpr[dst].val;
+        
+        if (auto nan = fpu.resolveNan(source, dest); nan) {
+            
+            result = *nan;
+            
+        } else {
+            
+            switch (I) {
+                    
+                case FADD: result = fpu.fadd(source, dest); break;
+                case FCMP: result = fpu.fcmp(source, dest); break;
+                case FDIV: result = fpu.fdiv(source, dest); break;
+                case FMOD: result = fpu.fmod(source, dest); break;
+                case FMUL: result = fpu.fmul(source, dest); break;
+                case FREM: result = fpu.frem(source, dest); break;
+                case FSCAL: result = fpu.fscal(source, dest); break;
+                case FSGLDIV: result = fpu.fsgldiv(source, dest); break;
+                case FSGLMUL: result = fpu.fsglmul(source, dest); break;
+                case FSUB: result = fpu.fsub(source, dest); break;
+                    
+                default:
+                    result = source;
+                    break;
+            }
+        }
+    }
+    
+    if (I == FTST || I == FCMP) {
+        
+        fpu.setConditionCodes(result);
+        
+    } else {
+        
+        fpu.fpr[dst].load(result);
+        fpu.setConditionCodes(dst);
+    }
+
+    prefetch<C>();
+    FINALIZE
+}
diff --git a/Emulator/Components/CPU/Moira/MoiraExec_cpp.h b/Emulator/Components/CPU/Moira/MoiraExec_cpp.h
index 2bf525816..d7b3da2fa 100644
--- a/Emulator/Components/CPU/Moira/MoiraExec_cpp.h
+++ b/Emulator/Components/CPU/Moira/MoiraExec_cpp.h
@@ -1742,8 +1742,6 @@ Moira::execClr(u16 opcode)
         int dst = _____________xxx(opcode);
 
         u32 ea = computeEA<C, M, S>(dst);
-        // updateAnPD<M, S>(dst);
-        // if (!misaligned<C>(ea)) updateAnPI<M, S>(dst);
 
         switch (M) {
 
@@ -2528,7 +2526,7 @@ template <Core C, Instr I, Mode M, Size S> void
 Moira::execLea(u16 opcode)
 {
     AVAILABILITY(C68000)
-
+    
     int src = _____________xxx(opcode);
     int dst = ____xxx_________(opcode);
 
@@ -3667,11 +3665,6 @@ Moira::execMoveCcrEa(u16 opcode)
     // Emulate (An)+ register modification
     updateAnPI<M, S>(dst);
 
-    /*
-    writeOp<C, M, S, POLL>(dst, getCCR());
-    prefetch<C>();
-    */
-
     //           00  10  20        00  10  20        00  10  20
     //           .b  .b  .b        .w  .w  .w        .l  .l  .l
     CYCLES_AI   ( 0,  0,  0,        0, 12,  8,        0,  0,  0)
diff --git a/Emulator/Components/CPU/Moira/MoiraFPU.cpp b/Emulator/Components/CPU/Moira/MoiraFPU.cpp
new file mode 100644
index 000000000..8b945ff34
--- /dev/null
+++ b/Emulator/Components/CPU/Moira/MoiraFPU.cpp
@@ -0,0 +1,1708 @@
+// -----------------------------------------------------------------------------
+// This file is part of Moira - A Motorola 68k emulator
+//
+// Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
+// Published under the terms of the MIT License
+// -----------------------------------------------------------------------------
+
+#include "config.h"
+#include "MoiraFPU.h"
+#include "Moira.h"
+#include "MoiraMacros.h"
+#include <cfenv>
+#include <sstream>
+
+namespace vamiga::moira {
+
+FpuExtended
+FPUReg::round()
+{
+    FpuExtended result = val;
+    
+    if (val.isfinite()) {
+        
+        if (fpu.getPrecision() == FPU_PREC_SINGLE) {
+            
+            result = FpuSingle(result, fpu.getRoundingMode(), fpu.exceptionHandler);
+        }
+        if (fpu.getPrecision() == FPU_PREC_DOUBLE) {
+            
+            result = FpuDouble(result, fpu.exceptionHandler);
+        }
+        if (issubnormal()) {
+            
+            fpu.setExcStatusBit(FPEXP_UNFL);
+        }
+    }
+    
+    return result;
+}
+
+void
+FPUReg::load(const FpuExtended other)
+{
+    val = other;
+    
+    // Round to the correct precision
+    val = round();
+    
+    // Normalize the result
+    val.normalize();
+}
+
+std::ostream &
+FPUReg::operator<<(std::ostream &stream)
+{
+    stream << val.raw.high << ":" << val.raw.low;
+    stream << " (" << val.asLongDouble() << ")";
+    
+    return stream;
+}
+
+FPU::FPU(Moira& ref) : moira(ref)
+{
+    static_assert(!REQUIRE_PRECISE_FPU || sizeof(long double) > 8,
+                  "No long double support. FPU inaccuracies may occur.");
+
+    reset();
+}
+
+void
+FPU::reset()
+{
+    for (int i = 0; i < 8; i++) {
+        fpr[i].reset();
+    }
+    
+    fpiar = 0;
+    fpsr = 0;
+    fpcr = 0;
+
+    resetState = true;
+}
+
+bool
+FPU::inResetState()
+{
+    /*
+    for (int i = 0; i < 8; i++) {
+        if (fpr[i].val != FpuExtended::nan) return false;
+    }
+    
+    return fpiar == 0 && fpsr == 0 && fpcr == 0;
+    */
+    return resetState;
+}
+
+FpuPrecision
+FPU::getPrecision() const
+{
+    switch (fpcr & 0xC0) {
+            
+        case 0x00:  return FPU_PREC_EXTENDED;
+        case 0x40:  return FPU_PREC_SINGLE;
+        default:    return FPU_PREC_DOUBLE;
+    }
+}
+
+FpuRoundingMode
+FPU::getRoundingMode() const
+{
+    switch (fpcr & 0x30) {
+            
+        case 0x00:  return FPU_RND_NEAREST;
+        case 0x10:  return FPU_RND_ZERO;
+        case 0x20:  return FPU_RND_DOWNWARD;
+        default:    return FPU_RND_UPWARD;
+    }
+}
+
+FpuRoundingMode
+FPU::fesetround(FpuRoundingMode mode)
+{
+    auto oldMode = fegetround();
+    
+    switch (mode) {
+            
+        case FPU_RND_NEAREST:   ::fesetround(FE_TONEAREST); break;
+        case FPU_RND_ZERO:      ::fesetround(FE_TOWARDZERO); break;
+        case FPU_RND_DOWNWARD:  ::fesetround(FE_DOWNWARD); break;
+        default:                ::fesetround(FE_UPWARD); break;
+    }
+    
+    switch (oldMode) {
+            
+        case FE_TONEAREST:      return FPU_RND_NEAREST;
+        case FE_TOWARDZERO:     return FPU_RND_ZERO;
+        case FE_DOWNWARD:       return FPU_RND_DOWNWARD;
+        default:                return FPU_RND_UPWARD;
+    }
+}
+
+int
+FPU::stateFrameSize(FpuFrameType type)
+{
+    switch (type) {
+            
+        case FPU_FRAME_IDLE:
+            
+            if (model == INTERNAL_FPU) return 0;
+            if (model == M68881) return 24;
+            if (model == M68882) return 56;
+    
+        case FPU_FRAME_UNIMP:
+            
+            if (model == INTERNAL_FPU) return 44;
+            if (model == M68881) return 0;
+            if (model == M68882) return 0;
+
+        case FPU_FRAME_BUSY:
+            
+            if (model == INTERNAL_FPU) return 92;
+            if (model == M68881) return 180;
+            if (model == M68882) return 212;
+            
+        default:
+            
+            return 0;
+    }
+}
+
+int
+FPU::stateFrameSize(u32 fmtWord)
+{
+    return BYTE2(fmtWord);
+}
+
+FpuFrameType
+FPU::typeOfFrame(u32 fmtWord)
+{
+    isize size = stateFrameSize(fmtWord);
+    
+    if (size == stateFrameSize(FPU_FRAME_NULL)) return FPU_FRAME_NULL;
+    if (size == stateFrameSize(FPU_FRAME_IDLE)) return FPU_FRAME_IDLE;
+    if (size == stateFrameSize(FPU_FRAME_UNIMP)) return FPU_FRAME_UNIMP;
+    if (size == stateFrameSize(FPU_FRAME_BUSY)) return FPU_FRAME_BUSY;
+    
+    return FPU_FRAME_INVALID;
+}
+
+u32
+FPU::computeFormatWord(FpuFrameType type)
+{
+    switch (type) {
+            
+        case FPU_FRAME_IDLE:
+        case FPU_FRAME_UNIMP:
+        case FPU_FRAME_BUSY:
+            
+            return 0x1F000000 | stateFrameSize(type) << 16;
+                        
+        default:
+            
+            return 0;
+    }
+}
+
+bool
+FPU::isValidExt(Instr I, Mode M, u16 op, u32 ext)
+{
+    auto cod  = xxx_____________ (ext);
+    auto mode = ___xx___________ (ext);
+    auto fmt  = ___xxx__________ (ext);
+    auto lst  = ___xxx__________ (ext);
+    auto cmd  = _________xxxxxxx (ext);
+    
+    switch (I) {
+            
+        case FDBcc:
+        case FScc:
+        case FTRAPcc:
+            
+            return (ext & 0xFFE0) == 0;
+            
+        case FMOVECR:
+            
+            return (op & 0x3F) == 0;
+            
+        case FMOVE:
+            
+            switch (cod) {
+                    
+                case 0b010:
+                    
+                    if (M == MODE_IP) break;
+                    return true;
+                    
+                case 0b000:
+                    
+                    if (cmd == 0 && cod == 0 && (op & 0x3F)) break;
+                    return true;
+                    
+                case 0b011:
+                    
+                    if (fmt != 0b011 && fmt != 0b111 && (ext & 0x7F)) break;
+                    
+                    if (M == MODE_DN) {
+                        if (fmt == 0b010 || fmt == 0b011 || fmt == 0b101 || fmt == 0b111) break;
+                    }
+                    if (M == MODE_AN) {
+                        if (fmt == 0b011 || fmt == 0b111) break;
+                    }
+                    if (M == MODE_DIPC || M == MODE_IXPC || M == MODE_IM || M == MODE_IP) {
+                        break;
+                    } else {
+                        if (fmt == 0b111 && (ext & 0xF)) break;
+                    }
+                    
+                    return true;
+            }
+            
+        case FMOVEM:
+            
+            switch (cod) {
+                    
+                case 0b101:
+                {
+                    
+                    if (ext & 0x3FF) break;
+                    
+                    if (M == MODE_DN || M == MODE_AN) {
+                        if (lst != 0b000 && lst != 0b001 && lst != 0b010 && lst != 0b100) break;
+                    }
+                    if (M == MODE_DIPC || M == MODE_IXPC || M == MODE_IM || M == MODE_IP) {
+                        break;
+                    }
+                    return true;
+                }
+                case 0b100:
+                    
+                    if (ext & 0x3FF) break;
+                    if (M == MODE_IP) break;
+                    return true;
+                    
+                case 0b110:
+                case 0b111:
+                    
+                    if (ext & 0x0700) break;
+                    if (mode == 3 && (ext & 0x8F)) break;
+                    
+                    if (M == MODE_DN || M == MODE_AN) {
+                        break;
+                    }
+                    if (M == MODE_DIPC || M == MODE_IXPC || M == MODE_IM || M == MODE_IP) {
+                        break;
+                    }
+                    if (M == MODE_AI) {
+                        if (mode == 0 || mode == 1) break;
+                    }
+                    if (M == MODE_PI) {
+                        if (mode == 0 || mode == 1 || cod == 0b111) break;
+                    }
+                    if (M == MODE_PD) {
+                        if (cod == 0b110) break;
+                        if (cod == 0b111 && (mode == 1) && (ext & 0x8F)) break;
+                        if (cod == 0b111 && (mode == 2 || mode == 3)) break;
+                    }
+                    if (M == MODE_DI || M == MODE_IX || M == MODE_AW || M == MODE_AL) {
+                        if (mode == 0 || mode == 1) break;
+                    }
+                    return true;
+            }
+            return false;
+            
+        default:
+            fatalError;
+    }
+}
+
+void
+FPU::setFPCR(u32 value)
+{
+    fpcr = value & 0x0000FFF0;
+    
+    softfloat::float_rounding_mode = (value & 0b110000) >> 4;
+}
+
+void
+FPU::setFPSR(u32 value)
+{
+    fpsr = value & 0x0FFFFFF8;
+}
+
+void
+FPU::setExcStatusBit(u32 mask)
+{
+    assert((mask & ~0xFF00) == 0);
+    
+    fpsr |= mask;
+    
+    // Set sticky bits (accrued exception byte)
+    if (fpsr & (FPEXP_SNAN | FPEXP_OPERR))                  SET_BIT(fpsr, 7);
+    if (fpsr & FPEXP_OVFL)                                  SET_BIT(fpsr, 6);
+    if ((fpsr & FPEXP_UNFL) && (fpsr & FPEXP_INEX2))        SET_BIT(fpsr, 5);
+    if (fpsr & FPEXP_DZ)                                    SET_BIT(fpsr, 4);
+    if (fpsr & (FPEXP_INEX1 | FPEXP_INEX2 | FPEXP_OVFL))    SET_BIT(fpsr, 3);
+}
+
+void
+FPU::clearExcStatusBit(u32 mask)
+{
+    assert((mask & ~0xFF00) == 0);
+    
+    fpsr &= ~mask;
+}
+
+void
+FPU::setConditionCodes(int reg)
+{
+    assert(reg >= 0 && reg <= 7);
+    setConditionCodes(fpr[reg].val);
+}
+
+void
+FPU::setConditionCodes(const FpuExtended &value)
+{
+    // printf("setConditionCodes: %x:%x %d %d %d %d\n", value.raw.high, value.raw.low, value.isnegative(), value.iszero(), value.isinf(), value.isnan());
+    REPLACE_BIT(fpsr, 27, value.isnegative());
+    REPLACE_BIT(fpsr, 26, value.iszero());
+    REPLACE_BIT(fpsr, 25, value.isinf());
+    REPLACE_BIT(fpsr, 24, value.isnan());
+}
+
+void
+FPU::setQuotientByte(u8 byte)
+{
+    fpsr &= 0xFF00FFFF;
+    fpsr |= byte << 16;
+}
+
+void
+FPU::setQuotientByte(u8 byte, bool sign)
+{
+    setQuotientByte((byte & 0x7F) | (sign ? 0x80 : 0x00));
+}
+
+void
+FPU::setFPIAR(u32 value)
+{
+    fpiar = value;
+}
+
+FpuExtended
+FPU::readCR(unsigned nr)
+{
+    FpuExtended result;
+    
+    typedef struct { u16 hi; u64 lo; i64 r1; i64 r2; bool inex; } RomEntry;
+    
+    static constexpr RomEntry rom1[] = {
+        
+        { 0x4000, 0xc90fdaa22168c235, -1,  0,  1 }, // 0x00: Pi
+        { 0x4001, 0xfe00068200000000,  0,  0,  0 }, // 0x01: Undocumented
+        { 0x4001, 0xffc0050380000000,  0,  0,  0 }, // 0x02: Undocumented
+        { 0x2000, 0x7FFFFFFF00000000,  0,  0,  0 }, // 0x03: Undocumented
+        { 0x0000, 0xFFFFFFFFFFFFFFFF,  0,  0,  0 }, // 0x04: Undocumented
+        { 0x3C00, 0xFFFFFFFFFFFFF800,  0,  0,  0 }, // 0x05: Undocumented
+        { 0x3F80, 0xFFFFFF0000000000,  0,  0,  0 }, // 0x06: Undocumented
+        { 0x0001, 0xF65D8D9C00000000,  0,  0,  0 }, // 0x07: Undocumented
+        { 0x7FFF, 0x401E000000000000,  0,  0,  0 }, // 0x08: Undocumented
+        { 0x43F3, 0xE000000000000000,  0,  0,  0 }, // 0x09: Undocumented
+        { 0x4072, 0xC000000000000000,  0,  0,  0 }, // 0x0A: Undocumented
+        { 0x3ffd, 0x9a209a84fbcff798,  0,  1,  1 }, // 0x0B: Log10(2)
+        { 0x4000, 0xadf85458a2bb4a9a,  0,  1,  1 }, // 0x0C: E
+        { 0x3fff, 0xb8aa3b295c17f0bc, -1,  0,  1 }, // 0x0D: Log2(e)
+        { 0x3ffd, 0xde5bd8a937287195,  0,  0,  0 }, // 0x0E: Log10(e)
+        { 0x0000, 0x0000000000000000,  0,  0,  0 }  // 0x0F: 0.0
+    };
+    
+    static constexpr RomEntry rom2[] = {
+        
+        { 0x3ffe, 0xb17217f7d1cf79ac, -1,  0,  1  }, // 0x00: Ln(2)
+        { 0x4000, 0x935d8dddaaa8ac17, -1,  0,  1  }, // 0x01: Ln(10)
+        { 0x3FFF, 0x8000000000000000,  0,  0,  0  }, // 0x02: 10^0
+        { 0x4002, 0xA000000000000000,  0,  0,  0  }, // 0x03: 10^1
+        { 0x4005, 0xC800000000000000,  0,  0,  0  }, // 0x04: 10^2
+        { 0x400C, 0x9C40000000000000,  0,  0,  0  }, // 0x05: 10^4
+        { 0x4019, 0xBEBC200000000000,  0,  0,  0  }, // 0x06: 10^8
+        { 0x4034, 0x8E1BC9BF04000000,  0,  0,  0  }, // 0x07: 10^16
+        { 0x4069, 0x9DC5ADA82B70B59E, -1,  0,  1  }, // 0x08: 10^32
+        { 0x40D3, 0xC2781F49FFCFA6D5,  0,  1,  1  }, // 0x09: 10^64
+        { 0x41A8, 0x93BA47C980E98CE0, -1,  0,  1  }, // 0x0A: 10^128
+        { 0x4351, 0xAA7EEBFB9DF9DE8E, -1,  0,  1  }, // 0x0B: 10^256
+        { 0x46A3, 0xE319A0AEA60E91C7, -1,  0,  1  }, // 0x0C: 10^512
+        { 0x4D48, 0xC976758681750C17,  0,  1,  1  }, // 0x0D: 10^1024
+        { 0x5A92, 0x9E8B3B5DC53D5DE5, -1,  0,  1  }, // 0x0E: 10^2048
+        { 0x7525, 0xC46052028A20979B, -1,  0,  1  }  // 0x0F: 10^4096
+    };
+    
+    auto readRom = [&](const RomEntry &entry) {
+        
+        auto result = FpuExtended(entry.hi, entry.lo);
+        
+        // Round if necessary
+        if ((fpcr & 0b110000) == 0b010000) result.raw.low += entry.r1;
+        if ((fpcr & 0b110000) == 0b100000) result.raw.low += entry.r1;
+        if ((fpcr & 0b110000) == 0b110000) result.raw.low += entry.r2;
+        
+        // Mark value as inexact if necessary
+        if (entry.inex) setExcStatusBit(FPEXP_INEX2);
+        
+        return result;
+    };
+    
+    if (nr >= 0x40) {
+        // Values in this range seem to produce a Guru on the real machine
+    }
+    
+    if (nr >= 0x00 && nr < 0x10) result = readRom(rom1[nr]);
+    if (nr >= 0x30 && nr < 0x40) result = readRom(rom2[nr - 0x30]);
+    
+    return result;
+}
+
+void
+FPU::clearHostFpuFlags()
+{
+    feclearexcept(FE_ALL_EXCEPT);
+}
+
+void
+FPU::copyHostFpuFlags()
+{
+    if (fetestexcept(FE_INEXACT))   { setExcStatusBit(FPEXP_INEX2); }
+    if (fetestexcept(FE_UNDERFLOW)) { setExcStatusBit(FPEXP_UNFL); }
+    if (fetestexcept(FE_OVERFLOW))  { setExcStatusBit(FPEXP_OVFL); }
+    if (fetestexcept(FE_DIVBYZERO)) { setExcStatusBit(FPEXP_DZ); }
+    if (fetestexcept(FE_INVALID))   { setExcStatusBit(FPEXP_OPERR); }
+}
+
+std::optional<FpuExtended>
+FPU::resolveNan(const FpuExtended &op1, const FpuExtended &op2)
+{
+    /* MC68881/MC68882 Floating-Point Coprocessor User's Manual:
+     *
+     * 4.5.4.1 NON-SIGNALING NANS
+     *
+     * "If either, but not both, operand of an operation is a NAN, and it is a
+     *  non-signaling NAN, then that NAN is returned as the result. If both
+     *  operands are non-signaling NANs, then the destination operand
+     *  non-signaling NAN is returned as the result.
+     *
+     * 4.5.4.2 SIGNALING NANS
+     *
+     * If either operand to an operation is a signaling NAN (SNAN), then the
+     * SNAN bit is set in the FPSR EXC byte. If the SNAN trap enable bit is
+     * set in the FPCR ENABLE byte, then the trap is taken and the destination
+     * is not modified. If the SNAN trap enable bit is not set, then the SNAN
+     * is converted to a non-signaling NAN (by setting the SNAN bit in the
+     * operand to a one), and the operation continues as described in the
+     * preceding section for non-signaling NANs.
+     */
+    
+    if (!op1.isnan() && !op2.isnan()) return {};
+    
+    auto o1 = op1;
+    auto o2 = op2;
+    
+    if (o1.isSignalingNaN()) {
+        
+        o1.raw.low |= (1LL << 62);
+        setExcStatusBit(FPEXP_SNAN);
+    }
+    if (o2.isSignalingNaN()) {
+        
+        o2.raw.low |= (1LL << 62);
+        setExcStatusBit(FPEXP_SNAN);
+    }
+    
+    return o2.isnan() ? o2 : o1;
+}
+
+std::optional<FpuExtended>
+FPU::resolveNan(const FpuExtended &op)
+{
+    if (!op.isnan()) return {};
+    
+    auto o = op;
+    
+    if (o.isSignalingNaN()) {
+        
+        o.raw.low |= (1LL << 62);
+        setExcStatusBit(FPEXP_SNAN);
+    }
+    
+    return o;
+}
+
+FpuExtended
+FPU::monadic(const FpuExtended &value, std::function<long double(long double)> func)
+{
+    clearHostFpuFlags();
+    auto result = func(value.asLongDouble());
+    copyHostFpuFlags();
+    
+    if (fetestexcept(FE_INVALID)) {
+        // printf("FPU::monadic FE_INVALID\n");
+        return FpuExtended(0x7FFF, 0x7FFFFFFFFFFFFFFF);
+    }
+    if (std::isnan(result)) {
+        // printf("FPU::monadic is_nan\n");
+        return FpuExtended(0x7FFF, 0x7FFFFFFFFFFFFFFF);
+    }
+
+    // printf("FPU::monadic\n");
+    return FpuExtended(result, getRoundingMode(), exceptionHandler);
+}
+
+FpuExtended
+FPU::fabs(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   abs(x)    | +0.0  +0.0  | +inf  +inf  |
+    // -------------------------------------------
+    
+    return FpuExtended(value.raw.high & 0x7FFF, value.raw.low);
+}
+
+FpuExtended
+FPU::facos(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   acos(x)   | pi/2  pi/2  |  NaN   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return FpuExtended(0x3FFF, 0xc90fdaa22168c235);
+    }
+    if (value.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (value < -1.0 || value > 1.0) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    
+    return monadic(value, [&](long double x) { return std::acos(x); });
+}
+
+FpuExtended
+FPU::fasin(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   asin(x)   | +0.0  -0.0  |  NaN   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (value < -1.0 || value > 1.0) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    
+    return monadic(value, [&](long double x) { return std::asin(x); });
+}
+
+FpuExtended
+FPU::fatan(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   atan(x)   | +0.0  -0.0  | +pi/2 -pi/2 |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return FpuExtended::zero.copysign(value);
+    }
+    if (value.isinf()) {
+        
+        return FpuExtended(0x3FFF, 0xc90fdaa22168c235).copysign(value);
+    }
+    
+    return monadic(value, [&](long double x) { return std::atan(x); });
+}
+
+FpuExtended
+FPU::fatanh(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |  atanh(x)   | +0.0  -0.0  |  NaN   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (value <= -1.0 || value >= 1.0) {
+        
+        if (value == -1.0) {
+            
+            setExcStatusBit(FPEXP_DZ);
+            return FpuExtended::negInf;
+        }
+        if (value == 1.0) {
+            
+            setExcStatusBit(FPEXP_DZ);
+            return FpuExtended::posInf;
+        }
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    
+    return monadic(value, [&](long double x) { return std::atanh(x); });
+}
+
+FpuExtended
+FPU::fcos(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   cos(x)    | +1.0  +1.0  |  NaN   NaN  |
+    // -------------------------------------------
+    
+    if (value.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    
+    return monadic(value, [&](long double x) { return std::cos(x); });
+}
+
+FpuExtended
+FPU::fcosh(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   cosh(x)   | +1.0  +1.0  | +inf  +inf  |
+    // -------------------------------------------
+    
+    if (value.isinf()) {
+        
+        return FpuExtended::posInf;
+    }
+    
+    return monadic(value, [&](long double x) { return std::cosh(x); });
+}
+
+FpuExtended
+FPU::fetox(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |     e^x     | +1.0  +1.0  | +inf  +0.0  |
+    // -------------------------------------------
+    
+    if (value.isinf()) {
+        return value.ispositive() ? value : FpuExtended::posZero;
+    }
+    
+    return monadic(value, [&](long double x) { return std::expl(x); });
+}
+
+FpuExtended
+FPU::fetoxm1(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   e^x - 1   | +0.0  -0.0  | +inf  -1.0  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isinf()) {
+        
+        return value.ispositive() ? value : -1.0;
+    }
+    
+    return monadic(value, [&](long double x) { return std::expl(x) - 1.0L; });
+}
+
+FpuExtended
+FPU::fgetexp(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   e^x - 1   | +0.0  -0.0  |  NaN   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    
+    return FpuExtended((value.raw.high & 0x7FFF) - FpuExtended::bias);
+}
+
+FpuExtended
+FPU::fgetman(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   Mantissa  | +0.0  -0.0  |  NaN   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    
+    return FpuExtended((value.raw.high & 0x8000) | 0x3FFF, value.raw.low);
+}
+
+FpuExtended
+FPU::fint(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   Integer   | +0.0  -0.0  | +inf  -inf  |
+    // -------------------------------------------
+    
+    if (value.iszero() || value.isinf()) {
+        
+        return value;
+    }
+    
+    softfloat::float_exception_flags = 0;
+    auto rounded = softfloat::floatx80_round_to_int(value.raw);
+    
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        setExcStatusBit(FPEXP_INEX2);
+    }
+    /*
+     if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+     flags |= FPEXP_OVFL;
+     }
+     if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+     flags |= FPEXP_UNFL;
+     }
+     */
+    
+    return FpuExtended(rounded.high, rounded.low);
+}
+
+FpuExtended
+FPU::fintrz(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   Integer   | +0.0  -0.0  | +inf  -inf  |
+    // -------------------------------------------
+    
+    if (value.iszero() || value.isinf()) {
+        
+        return value;
+    }
+    
+    softfloat::float_exception_flags = 0;
+    auto oldmode = softfloat::float_rounding_mode;
+    softfloat::float_rounding_mode = 1;
+    auto rounded = softfloat::floatx80_round_to_int(value.raw);
+    softfloat::float_rounding_mode = oldmode;
+    
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        setExcStatusBit(FPEXP_INEX2);
+    }
+    /*
+     if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+     flags |= FPEXP_OVFL;
+     }
+     if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+     flags |= FPEXP_UNFL;
+     }
+     */
+    
+    return FpuExtended(rounded.high, rounded.low);
+}
+
+FpuExtended
+FPU::flog10(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |  log10(x)   | -inf  -inf  | +inf   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        setExcStatusBit(FPEXP_DZ);
+        return FpuExtended::negInf;
+    }
+    if (value.isnegative()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (value.isinf()) {
+        
+        if (value.ispositive()) {
+            
+            return FpuExtended::posInf;
+            
+        } else {
+            
+            setExcStatusBit(FPEXP_OPERR);
+            return FpuExtended::nan;
+        }
+    }
+    
+    return monadic(value, [&](long double x) { return std::log10(x); });
+}
+
+FpuExtended
+FPU::flog2(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |    ld(x)    | -inf  -inf  | +inf   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        setExcStatusBit(FPEXP_DZ);
+        return FpuExtended::negInf;
+    }
+    if (value.isnegative()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (value.isinf()) {
+        
+        if (value.ispositive()) {
+            
+            return FpuExtended::posInf;
+            
+        } else {
+            
+            setExcStatusBit(FPEXP_OPERR);
+            return FpuExtended::nan;
+        }
+    }
+    
+    return monadic(value, [&](long double x) { return std::log2(x); });
+}
+
+FpuExtended
+FPU::flogn(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |    ln(x)    | -inf  -inf  | +inf   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        setExcStatusBit(FPEXP_DZ);
+        return FpuExtended::negInf;
+    }
+    if (value.isnegative()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (value.isinf()) {
+        
+        if (value.ispositive()) {
+            
+            return FpuExtended::posInf;
+            
+        } else {
+            
+            setExcStatusBit(FPEXP_OPERR);
+            return FpuExtended::nan;
+        }
+    }
+    
+    return monadic(value, [&](long double x) { return std::log(x); });
+}
+
+FpuExtended
+FPU::flognp1(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |  ln(x - 1)  | +0.0  -0.0  | +inf   NaN  |
+    // -------------------------------------------
+    
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value == -1.0) {
+        
+        setExcStatusBit(FPEXP_DZ);
+        return FpuExtended::negInf;
+    }
+    if (value < -1.0) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (value.isinf()) {
+        
+        if (value.ispositive()) {
+            
+            return FpuExtended::posInf;
+            
+        } else {
+            
+            setExcStatusBit(FPEXP_OPERR);
+            return FpuExtended::nan;
+        }
+    }
+    
+    return monadic(value, [&](long double x) { return std::log(x + 1); });
+}
+
+FpuExtended
+FPU::fneg(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |     -x      | -0.0  +0.0  | -inf  +inf  |
+    // -------------------------------------------
+    
+    return FpuExtended(value.raw.high ^0x8000, value.raw.low);
+}
+
+FpuExtended
+FPU::fsin(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   sin(x)    | +0.0  -0.0  |  NaN   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    return monadic(value, [&](long double x) { return std::sin(x); });
+}
+
+FpuExtended
+FPU::fsinh(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   sinh(x)   | +0.0  -0.0  | +inf  -inf  |
+    // -------------------------------------------
+    
+    if (value.iszero() || value.isinf()) {
+        
+        return value;
+    }
+    
+    return monadic(value, [&](long double x) { return std::sinh(x); });
+}
+
+FpuExtended
+FPU::fsqrt(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   sqrt(x)   | +0.0  -0.0  | +inf   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isnegative()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (value.isinf()) {
+        
+        return value;
+    }
+    
+    return monadic(value, [&](long double x) { return std::sqrt(x); });
+}
+
+FpuExtended
+FPU::ftan(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   tan(x)    | +0.0  -0.0  |  NaN   NaN  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    
+    return monadic(value, [&](long double x) { return std::tan(x); });
+}
+
+FpuExtended
+FPU::ftanh(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |   tanh(x)   | +0.0  -0.0  | +1.0  -1.0  |
+    // -------------------------------------------
+    
+    if (value.iszero()) {
+        
+        return value;
+    }
+    if (value.isinf()) {
+        
+        return value.ispositive() ? 1.0 : -1.0;
+    }
+    
+    return monadic(value, [&](long double x) { return std::tanh(x); });
+}
+
+FpuExtended
+FPU::ftentox(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |    10^x     | +1.0  +1.0  | +inf  +0.0  |
+    // -------------------------------------------
+    
+    if (value.isinf()) {
+        
+        return value.ispositive() ? value : FpuExtended::posZero;
+    }
+    
+    return monadic(value, [&](long double x) { return std::powl(10.0L, x); });
+}
+
+FpuExtended
+FPU::ftst(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |  { }   N    |   Z     NZ  |   I     NI  |
+    // -------------------------------------------
+    
+    return value;
+}
+
+FpuExtended
+FPU::ftwotox(const FpuExtended &value)
+{
+    // -------------------------------------------
+    // |  In Range   |    Zero     |  Infinity   |
+    // |   +    -    |   +     -   |   +     -   |
+    // -------------------------------------------
+    // |     2^x     | +1.0  +1.0  | +inf  +0.0  |
+    // -------------------------------------------
+    
+    if (value.isinf()) {
+        
+        return value.ispositive() ? value : FpuExtended::posZero;
+    }
+    
+    return monadic(value, [&](long double x) { return std::powl(2.0L, x); });
+}
+
+FpuExtended
+FPU::fadd(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |  Addition   |  Addition   | +0.0  -0.0  |
+    //          - |             |             | +0.0  -0.0  |
+    // ------------------------------------------------------
+    // Zero     + |  Addition   | +0.0  ?0.0  | +0.0  -0.0  |
+    //          - |             | ?0.0  -0.0  | +0.0  -0.0  |
+    // ------------------------------------------------------
+    // Infinity + | +inf  +inf  | +inf  +inf  | +inf   NaN  |
+    //          - | -inf  -inf  | -inf  -inf  |  NaN  -inf  |
+    // ------------------------------------------------------
+    // ? : +/- sign depends on rounding mode
+    
+    if (op1.iszero() && op2.iszero()) {
+        
+        if (op1.signbit() == op2.signbit()) {
+            return op1;
+        } else if (getRoundingMode() == FPU_RND_DOWNWARD) {
+            return FpuExtended::negZero;
+        } else {
+            return FpuExtended::posZero;
+        }
+    }
+    if (op1.isinf() && op2.isinf() && op1.signbit() != op2.signbit()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (op1.isinf()) {
+        
+        return op1;
+    }
+    if (op2.isinf()) {
+        
+        return op2;
+    }
+    
+    softfloat::float_exception_flags = 0;
+    
+    auto result = softfloat::floatx80_add(op1.raw, op2.raw);
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        setExcStatusBit(FPEXP_INEX2);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        setExcStatusBit(FPEXP_OVFL);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        setExcStatusBit(FPEXP_UNFL);
+    }
+    
+    return FpuExtended(result.high, result.low);
+}
+
+FpuExtended
+FPU::fcmp(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |  {NZ}   -   |   -     -   |   N     -   |
+    //          - |   N    {NZ} |   N     N   |   N     -   |
+    // ------------------------------------------------------
+    // Zero     + |   N     -   |   Z     Z   |   N     -   |
+    //          - |   N     -   |  NZ    NZ   |   N     -   |
+    // ------------------------------------------------------
+    // Infinity + |   -     -   |   -     -   |   Z     -   |
+    //          - |   N     N   |   N     N   |   N    NZ   |
+    // ------------------------------------------------------
+    
+    if (op1.iszero() && op2.iszero()) {
+        
+        return op2;
+    }
+    if (op1.iszero()) {
+        
+        return op2.signbit() ? -1 : 1;
+    }
+    if (op2.iszero()) {
+        
+        return op1.signbit() ? 1 : -1;
+    }
+    if (op1.isinf() && op2.isinf()) {
+        
+        if (op1.signbit() == 0 && op2.signbit() == 0) return FpuExtended::posZero;
+        if (op1.signbit() == 0 && op2.signbit() == 1) return -1;
+        if (op1.signbit() == 1 && op2.signbit() == 0) return 1;
+        if (op1.signbit() == 1 && op2.signbit() == 1) return FpuExtended::negZero;
+    }
+    if (op1.isinf()) {
+        
+        return op1.signbit() ? 1 : -1;
+    }
+    if (op2.isinf()) {
+        
+        return op2.signbit() ? -1 : 1;
+    }
+    if (op1 == op2) {
+        
+        return op1.signbit() ? FpuExtended::negZero : FpuExtended::posZero;
+    }
+    if (op2.ispositive()) {
+        
+        return op1 > op2 ? -1.0 : 1.0;
+    }
+    return op1 < op2 ? 1.0 : -1.0;
+}
+
+FpuExtended
+FPU::fdiv(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |     y/x     | +inf* -inf* | +0.0  -0.0  |
+    //          - |             | -inf* +inf* | -0.0  +0.0  |
+    // ------------------------------------------------------
+    // Zero     + | +0.0  -0.0  |  NaN   NaN  | +0.0  -0.0  |
+    //          - | -0.0  +0.0  |  NaN   NaN  | -0.0  +0.0  |
+    // ------------------------------------------------------
+    // Infinity + | +inf  -inf  | +inf  -inf  |  NaN   NaN  |
+    //          - | -inf  +inf  | -inf  +inf  |  NaN   NaN  |
+    // ------------------------------------------------------
+    // * : Sets DZ flag
+    
+    if ((op1.iszero() && op2.iszero()) || (op1.isinf() && op2.isinf())) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (op1.isinf()) {
+        return op1.signbit() == op2.signbit() ? FpuExtended::posZero : FpuExtended::negZero;
+    }
+    if (op2.isinf()) {
+        return op1.signbit() == op2.signbit() ? FpuExtended::posInf : FpuExtended::negInf;
+    }
+    if (op1.iszero()) {
+        
+        setExcStatusBit(FPEXP_DZ);
+        return op1.signbit() == op2.signbit() ? FpuExtended::posInf : FpuExtended::negInf;
+    }
+    if (op2.iszero()) {
+        return op1.signbit() == op2.signbit() ? FpuExtended::posZero : FpuExtended::negZero;
+    }
+    
+    softfloat::float_exception_flags = 0;
+    auto result = softfloat::floatx80_div(op2.raw, op1.raw);
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        setExcStatusBit(FPEXP_INEX2);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        setExcStatusBit(FPEXP_OVFL);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        setExcStatusBit(FPEXP_UNFL);
+    }
+    
+    return FpuExtended(result.high, result.low);
+}
+
+FpuExtended
+FPU::fmod(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |   Modulo    |  NaN   NaN  |     FPn     |
+    //          - |  Remainder  |  NaN   NaN  |             |
+    // ------------------------------------------------------
+    // Zero     + | +0.0  +0.0  |  NaN   NaN  | +0.0  +0.0  |
+    //          - | -0.0  -0.0  |  NaN   NaN  | -0.0  -0.0  |
+    // ------------------------------------------------------
+    // Infinity + |  NaN   NaN  |  NaN   NaN  |  NaN   NaN  |
+    //          - |  NaN   NaN  |  NaN   NaN  |  NaN   NaN  |
+    // ------------------------------------------------------
+    
+    long double modulus;
+    
+    if (op1.iszero() || op2.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (op2.iszero()) {
+        
+        return op2;
+    }
+    if (op1.isinf()) {
+        
+        modulus = op2.asLongDouble();
+        
+    } else {
+        
+        clearHostFpuFlags();
+        modulus = std::fmodl(op2.asLongDouble(), op1.asLongDouble());
+        copyHostFpuFlags();
+    }
+    
+    auto result = FpuExtended(modulus, getRoundingMode(), exceptionHandler);
+    setQuotientByte((u8)result.raw.low, op1.signbit() != op2.signbit());
+    return result;
+}
+
+FpuExtended
+FPU::fmul(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |    x * y    | +0.0  -0.0  | +inf  -inf  |
+    //          - |             | -0.0  +0.0  | -inf  +inf  |
+    // ------------------------------------------------------
+    // Zero     + | +0.0  -0.0  | +0.0  -0.0  |  NaN   NaN  |
+    //          - | -0.0  +0.0  | -0.0  +0.0  |  NaN   NaN  |
+    // ------------------------------------------------------
+    // Infinity + | +inf  -inf  |  NaN   NaN  | +inf  -inf  |
+    //          - | -inf  +inf  |  NaN   NaN  | -inf  +inf  |
+    // ------------------------------------------------------
+    
+    if (op1.isinf() || op2.isinf()) {
+        
+        if (op1.iszero() || op2.iszero()) {
+            
+            setExcStatusBit(FPEXP_OPERR);
+            return FpuExtended::nan;
+            
+        } else {
+            
+            return FpuExtended::inf.copysign(op1.signbit() != op2.signbit());
+        }
+    }
+    if (op1.iszero() || op2.iszero()) {
+        
+        return FpuExtended::zero.copysign(op1.signbit() != op2.signbit());
+    }
+    
+    softfloat::float_exception_flags = 0;
+    auto result = softfloat::floatx80_mul(op1.raw, op2.raw);
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        setExcStatusBit(FPEXP_INEX2);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        setExcStatusBit(FPEXP_OVFL);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        setExcStatusBit(FPEXP_UNFL);
+    }
+    
+    return FpuExtended(result.high, result.low);
+}
+
+FpuExtended
+FPU::frem(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |    IEEE     |  NaN   NaN  |  FPn   FPn  |
+    //          - |  Remainder  |  NaN   NaN  |  FPn   FPn  |
+    // ------------------------------------------------------
+    // Zero     + | +0.0  +0.0  |  NaN   NaN  | +0.0  +0.0  |
+    //          - | -0.0  -0.0  |  NaN   NaN  | -0.0  -0.0  |
+    // ------------------------------------------------------
+    // Infinity + |  NaN   NaN  |  NaN   NaN  |  NaN   NaN  |
+    //          - |  NaN   NaN  |  NaN   NaN  |  NaN   NaN  |
+    // ------------------------------------------------------
+    
+    if (op1.iszero() || op2.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (op2.iszero()) {
+        
+        return op2;
+    }
+    if (op1.isinf()) {
+        
+        return op2;
+    }
+    
+    softfloat::float_exception_flags = 0;
+    auto remainder = softfloat::floatx80_rem(op2.raw, op1.raw);
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        setExcStatusBit(FPEXP_INEX2);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        setExcStatusBit(FPEXP_OVFL);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        setExcStatusBit(FPEXP_UNFL);
+    }
+    
+    setQuotientByte((u8)remainder.low, op1.signbit() != op2.signbit());
+    return FpuExtended(remainder.high, remainder.low);
+}
+
+FpuExtended
+FPU::fscal(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |    Scale    |     FPn     |  NaN   NaN  |
+    //          - |   Exponent  |     FPn     |  NaN   NaN  |
+    // ------------------------------------------------------
+    // Zero     + | +0.0  +0.0  | +0.0  +0.0  |  NaN   NaN  |
+    //          - | -0.0  -0.0  | -0.0  -0.0  |  NaN   NaN  |
+    // ------------------------------------------------------
+    // Infinity + | +inf  +inf  | +inf  +inf  |  NaN   NaN  |
+    //          - | -inf  -inf  | -inf  -inf  |  NaN   NaN  |
+    // ------------------------------------------------------
+    
+    if (op1.isinf()) {
+        
+        setExcStatusBit(FPEXP_OPERR);
+        return FpuExtended::nan;
+    }
+    if (op2.isinf() || op2.iszero()) {
+        
+        return op2;
+    }
+    if (op1.iszero()) {
+        
+        return op2;
+    }
+    
+    long offset = (long)op1.asLongDouble();
+    
+    printf("fscale: op1 = %Lf offset = %ld\n", op1.asLongDouble(), offset);
+    
+    auto sgn = op2.signbit();
+    auto man = op2.man();
+    auto exp = op2.exp();
+    
+    return FpuExtended(sgn, exp + offset, man, exceptionHandler);
+}
+
+FpuExtended
+FPU::fsgldiv(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |     y/x     | +inf* -inf* | +0.0  -0.0  |
+    //          - |             | -inf* +inf* | -0.0  +0.0  |
+    // ------------------------------------------------------
+    // Zero     + | +0.0  -0.0  |  NaN   NaN  | +0.0  -0.0  |
+    //          - | -0.0  +0.0  |  NaN   NaN  | -0.0  +0.0  |
+    // ------------------------------------------------------
+    // Infinity + | +inf  -inf  | +inf  -inf  |  NaN   NaN  |
+    //          - | -inf  +inf  | -inf  +inf  |  NaN   NaN  |
+    // ------------------------------------------------------
+    //  * : Sets DZ flag
+    
+    auto result = fdiv(op1, op2);
+    
+    // TODO: Round
+    
+    return result;
+}
+
+FpuExtended
+FPU::fsglmul(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |    x * y    | +0.0  -0.0  | +inf  -inf  |
+    //          - |             | -0.0  +0.0  | -inf  +inf  |
+    // ------------------------------------------------------
+    // Zero     + | +0.0  -0.0  | +0.0  -0.0  |  NaN   NaN  |
+    //          - | -0.0  +0.0  | -0.0  +0.0  |  NaN   NaN  |
+    // ------------------------------------------------------
+    // Infinity + | +inf  -inf  |  NaN   NaN  | +inf  -inf  |
+    //          - | -inf  +inf  |  NaN   NaN  | -inf  +inf  |
+    // ------------------------------------------------------
+    
+    auto result = fmul(op1, op2);
+    
+    // TODO: Round
+    
+    return result;
+}
+
+FpuExtended
+FPU::fsub(const FpuExtended &op1, const FpuExtended &op2)
+{
+    // ------------------------------------------------------
+    //            |  In Range   |    Zero     |  Infinity   |
+    //            |   +    -    |   +     -   |   +     -   |
+    // ------------------------------------------------------
+    // In Range + |  Subtract   |  Subtract   | -inf  +inf  |
+    //          - |             |             | -inf  +inf  |
+    // ------------------------------------------------------
+    // Zero     + |  Subtract   | ?0.0  -0.0  | -inf  +inf  |
+    //          - |             | -0.0  ?0.0  | -inf  +inf  |
+    // ------------------------------------------------------
+    // Infinity + | +inf  +inf  | +inf  +inf  |  NaN  -inf  |
+    //          - | -inf  -inf  | -inf  -inf  | -inf   NaN  |
+    // ------------------------------------------------------
+    // ? : +/- sign depends on rounding mode
+    
+    if (op1.iszero() && op2.iszero()) {
+        
+        if (op1.signbit() != op2.signbit()) {
+            return FpuExtended::negZero;
+        } else if (getRoundingMode() == FPU_RND_DOWNWARD) {
+            return FpuExtended::negZero;
+        } else {
+            return FpuExtended::posZero;
+        }
+    }
+    if (op1.isinf() && op2.isinf()) {
+        
+        if (op1.signbit() == op2.signbit()) {
+            setExcStatusBit(FPEXP_OPERR);
+            return FpuExtended::nan;
+        } else {
+            return FpuExtended::negInf;
+        }
+    }
+    if (op1.isinf()) {
+        
+        return -op1;
+    }
+    if (op2.isinf()) {
+        
+        return op2;
+    }
+    
+    softfloat::float_exception_flags = 0;
+    
+    auto result = softfloat::floatx80_sub(op2.raw, op1.raw);
+    if (softfloat::float_exception_flags & softfloat::float_flag_inexact) {
+        setExcStatusBit(FPEXP_INEX2);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_overflow) {
+        setExcStatusBit(FPEXP_OVFL);
+    }
+    if (softfloat::float_exception_flags & softfloat::float_flag_underflow) {
+        setExcStatusBit(FPEXP_UNFL);
+    }
+    
+    return FpuExtended(result.high, result.low);
+}
+
+bool
+FPU::cpcc(u8 condition) const
+{
+    bool n = fpsr & FPCC_N;
+    bool z = fpsr & FPCC_Z;
+    bool nan = fpsr & FPCC_NAN;
+    
+    switch (condition)
+    {
+        case 0x10:
+        case 0x00:  return false;
+        case 0x11:
+        case 0x01:  return z;
+        case 0x12:
+        case 0x02:  return !(nan || z || n);
+        case 0x13:
+        case 0x03:  return z || !(nan || n);
+        case 0x14:
+        case 0x04:  return n && !(nan || z);
+        case 0x15:
+        case 0x05:  return z || (n && !nan);
+        case 0x16:
+        case 0x06:  return !nan && !z;
+        case 0x17:
+        case 0x07:  return !nan || z;
+        case 0x18:
+        case 0x08:  return nan;
+        case 0x19:
+        case 0x09:  return nan || z;
+        case 0x1a:
+        case 0x0a:  return nan || !(n || z);
+        case 0x1b:
+        case 0x0b:  return nan || z || !n;
+        case 0x1c:
+        case 0x0c:  return nan || (n && !z);
+        case 0x1d:
+        case 0x0d:  return nan || z || n;
+        case 0x1e:
+        case 0x0e:  return nan || !z;
+        case 0x1f:
+        case 0x0f:  return true;
+            
+        default:
+            fatalError;
+    }
+}
+
+}
diff --git a/Emulator/Components/CPU/Moira/MoiraFPU.h b/Emulator/Components/CPU/Moira/MoiraFPU.h
new file mode 100644
index 000000000..b228fb2b0
--- /dev/null
+++ b/Emulator/Components/CPU/Moira/MoiraFPU.h
@@ -0,0 +1,333 @@
+// -----------------------------------------------------------------------------
+// This file is part of Moira - A Motorola 68k emulator
+//
+// Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
+// Published under the terms of the MIT License
+// -----------------------------------------------------------------------------
+
+#pragma once
+
+#include "MoiraTypes.h"
+#include "FpuFormats.h"
+
+namespace vamiga::moira {
+
+class FPUReg {
+
+    // Reference to the FPU
+    class FPU &fpu;
+
+public:
+
+    // Register value
+    FpuExtended val;
+
+
+    //
+    // Constructing
+    //
+
+    FPUReg(FPU& fpu) : fpu(fpu) { }
+    void reset() { val = FpuExtended::nan; }
+
+
+    //
+    // Accessing
+    //
+
+    // Getter and setter
+    FpuExtended get() const { return val; }
+    void set(const FpuExtended other) { val = other; }
+
+    // Rounds the stored value according to the current rounding mode
+    FpuExtended round();
+    
+    // Same as set with additional rounding and normalization
+    void load(const FpuExtended other);
+
+
+    //
+    // Classifying
+    //
+
+    int fpclassify() const { return val.fpclassify(); }
+    bool isfinite() const { return val.isfinite(); }
+    bool isinf() const { return val.isinf(); }
+    bool isnan() const { return val.isnan(); }
+    bool isnormal() const { return val.isnormal(); }
+    bool issubnormal() const { return val.issubnormal(); }
+    bool signbit() const { return val.signbit(); }
+
+    bool isNegative() const { return val.isnegative(); }
+    bool isZero() const  { return val.iszero(); }
+    bool isSignalingNaN() const { return val.isSignalingNaN(); }
+    bool isNonsignalingNaN() const { return val.isNonsignalingNaN(); }
+
+    std::ostream &operator<<(std::ostream &stream);
+};
+
+class FPU {
+    
+public:
+    
+    // Reference to the CPU
+    class Moira &moira;
+    
+    // Emulated FPU model
+    FPUModel model = INTERNAL_FPU;
+    
+public:
+    
+    // Floating-point data registers FP0 to FP7
+    FPUReg fpr[8] = {
+        
+        FPUReg(*this),
+        FPUReg(*this),
+        FPUReg(*this),
+        FPUReg(*this),
+        FPUReg(*this),
+        FPUReg(*this),
+        FPUReg(*this),
+        FPUReg(*this)
+    };
+    
+    // Control register
+    u32 fpcr;
+
+    // Status register
+    u32 fpsr;
+
+    // Instruction address register
+    u32 fpiar;
+
+    // Indicates whether the FPU is in reset state (affects FSAVE)
+    bool resetState;
+
+
+    //
+    // Constructing
+    //
+    
+public:
+    
+    FPU(Moira& ref);
+    
+    // Initializes all registers with their reset values
+    void reset();
+    
+    // Indicates whether the FPU is in reset state (used by FSAVE)
+    bool inResetState();
+    
+    
+    //
+    // Configuring
+    //
+    
+public:
+
+    // Gets or sets the emulated CPU model
+    FPUModel getModel() const { return model; }
+    void setModel(FPUModel newModel) { model = newModel; }
+    
+    // Returns the precision and rounding mode, as specified in the FPCR
+    FpuPrecision getPrecision() const;
+    FpuRoundingMode getRoundingMode() const;
+    
+    // Configures the rounding mode of the host FPU
+    static FpuRoundingMode fesetround(FpuRoundingMode mode);
+    
+    
+    //
+    // Accessing registers
+    //
+    
+public:
+    
+    // Accesses the control register
+    u32 getFPCR() const { return fpcr & 0x0000FFF0; }
+    void setFPCR(u32 value);
+    
+    // Accesses the status register
+    u32 getFPSR() const { return fpsr & 0x0FFFFFF8; }
+    void setFPSR(u32 value);
+
+    void clearExcStatusByte() { fpsr &= 0xFFFF00FF; }
+    void clearExcStatusBit(u32 mask);
+    void setExcStatusBit(u32 mask);
+    
+    void setConditionCodes(int reg);
+    void setConditionCodes(const FpuExtended &value);
+    
+    void setQuotientByte(u8 byte);
+    void setQuotientByte(u8 byte, bool sign);
+
+    // Accesses the instruction address register
+    u32 getFPIAR() const { return fpiar; }
+    void setFPIAR(u32 value);
+    
+    
+    //
+    // Accessing the constant Rom
+    //
+    
+    // Reads a value from the constant Rom
+    FpuExtended readCR(unsigned nr);
+    
+    
+    //
+    // Analyzing instructions
+    //
+    
+public:
+    
+    // Returns true iff instruction I is supported by a certain FPU model
+    template <Instr I> static bool isSupported(FPUModel model)
+    {
+        switch (I) {
+                
+            case FACOS:     case FASIN:     case FATANH:    case FCOS:
+            case FCOSH:     case FETOX:     case FETOXM1:   case FGETEXP:
+            case FGETMAN:   case FINTRZ:    case FLOG10:    case FLOG2:
+            case FLOGN:     case FLOGNP1:   case FMOD:      case FREM:
+            case FSCAL:     case FSIN:      case FSINCOS:   case FSINH:
+            case FTAN:      case FTANH:     case FTENTOX:   case FTWOTOX:
+                
+                return model == M68881 || model == M68882;
+                
+            default:
+                
+                return true;
+        }
+    }
+    template <Instr I> bool isSupported() { return isSupported<I>(model); }
+    
+    // Returns true iff instruction I is a monadic arithmetic instruction
+    template <Instr I> static bool isMonadic()
+    {
+        switch (I) {
+                
+            case FABS:      case FACOS:     case FASIN:     case FATAN:
+            case FATANH:    case FCOS:      case FCOSH:     case FETOX:
+            case FETOXM1:   case FGETEXP:   case FGETMAN:   case FINT:
+            case FINTRZ:    case FLOG10:    case FLOG2:     case FLOGN:
+            case FLOGNP1:   case FNEG:      case FSIN:      case FSINCOS:
+            case FSINH:     case FSQRT:     case FTAN:      case FTANH:
+            case FTENTOX:   case FTST:      case FTWOTOX:
+                
+                return true;
+                
+            default:
+                
+                return false;
+        }
+    }
+    
+    // Returns true iff instruction I is a dyadic arithmetic instruction
+    template <Instr I> static bool isDyadic()
+    {
+        switch (I) {
+                
+            case FADD:      case FCMP:      case FDIV:      case FMOD:
+            case FMUL:      case FREM:      case FSCAL:     case FSGLDIV:
+            case FSGLMUL:   case FSUB:
+                
+                return true;
+                
+            default:
+                
+                return false;
+        }
+    }
+    
+    // Checks the validity of the extension words
+    static bool isValidExt(Instr I, Mode M, u16 op, u32 ext);
+    
+    
+    //
+    // Working with state frames (FSAVE, FRESTORE)
+    //
+    
+    // Determines the size of a state frame (varies between FPU models)
+    int stateFrameSize(FpuFrameType type);
+    int stateFrameSize(u32 fmtWord);
+    
+    // Determines the type a state frame
+    FpuFrameType typeOfFrame(u32 fmtWord);
+
+    // Computes a format word for a fiven frame type
+    u32 computeFormatWord(FpuFrameType type);
+
+    
+    //
+    // Managing the host FPU
+    //
+    
+    // Clears the exception flags of the host FPU
+    void clearHostFpuFlags();
+    
+    // Copies the exception flags of the host FPU into FPSR
+    void copyHostFpuFlags();
+    
+    
+    //
+    // Handling special values
+    //
+        
+    // Checks the arguments for NaNs and computes the result NaN if applicable
+    std::optional<FpuExtended> resolveNan(const FpuExtended &op1, const FpuExtended &op2);
+    std::optional<FpuExtended> resolveNan(const FpuExtended &op);
+    
+    
+    //
+    // Executing instructions
+    //
+    
+    std::function<void(int)> exceptionHandler = [this](int flags) { setExcStatusBit(flags); };
+    
+    FpuExtended monadic(const FpuExtended &value, std::function<long double(long double)> func);
+    
+    // Monadic operations
+    FpuExtended fabs(const FpuExtended &value);
+    FpuExtended facos(const FpuExtended &value);
+    FpuExtended fasin(const FpuExtended &value);
+    FpuExtended fatan(const FpuExtended &value);
+    FpuExtended fatanh(const FpuExtended &value);
+    FpuExtended fcos(const FpuExtended &value);
+    FpuExtended fcosh(const FpuExtended &value);
+    FpuExtended fetox(const FpuExtended &value);
+    FpuExtended fetoxm1(const FpuExtended &value);
+    FpuExtended fgetexp(const FpuExtended &value);
+    FpuExtended fgetman(const FpuExtended &value);
+    FpuExtended fint(const FpuExtended &value);
+    FpuExtended fintrz(const FpuExtended &value);
+    FpuExtended flog10(const FpuExtended &value);
+    FpuExtended flog2(const FpuExtended &value);
+    FpuExtended flogn(const FpuExtended &value);
+    FpuExtended flognp1(const FpuExtended &value);
+    FpuExtended fneg(const FpuExtended &value);
+    FpuExtended fsin(const FpuExtended &value);
+    FpuExtended fsinh(const FpuExtended &value);
+    FpuExtended fsqrt(const FpuExtended &value);
+    FpuExtended ftan(const FpuExtended &value);
+    FpuExtended ftanh(const FpuExtended &value);
+    FpuExtended ftentox(const FpuExtended &value);
+    FpuExtended ftst(const FpuExtended &value);
+    FpuExtended ftwotox(const FpuExtended &value);
+
+    // Dyadic operations
+    FpuExtended fadd(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended fcmp(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended fdiv(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended fmod(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended fmul(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended frem(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended fscal(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended fsgldiv(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended fsglmul(const FpuExtended &op1, const FpuExtended &op2);
+    FpuExtended fsub(const FpuExtended &op1, const FpuExtended &op2);
+        
+    // Performs a coprocessor condition test
+    bool cpcc(u8 condition) const;
+};
+
+}
diff --git a/Emulator/Components/CPU/Moira/MoiraInit.h b/Emulator/Components/CPU/Moira/MoiraInit.h
index b095961f6..2653cf198 100644
--- a/Emulator/Components/CPU/Moira/MoiraInit.h
+++ b/Emulator/Components/CPU/Moira/MoiraInit.h
@@ -189,7 +189,7 @@ MOIRA_DECLARE(FTrapcc)
 MOIRA_DECLARE(FMove)
 MOIRA_DECLARE(FMovecr)
 MOIRA_DECLARE(FMovem)
-MOIRA_DECLARE_DASM(FGeneric)
+MOIRA_DECLARE(FGeneric)
 MOIRA_DECLARE_DASM(FGeneric2)
 MOIRA_DECLARE_DASM(FGeneric3)
 
diff --git a/Emulator/Components/CPU/Moira/MoiraInit_cpp.h b/Emulator/Components/CPU/Moira/MoiraInit_cpp.h
index 4df0a9945..13a476c28 100644
--- a/Emulator/Components/CPU/Moira/MoiraInit_cpp.h
+++ b/Emulator/Components/CPU/Moira/MoiraInit_cpp.h
@@ -1924,6 +1924,7 @@ Moira::createJumpTable(Model model, bool regDasm)
             ____XXX______XXX(opcode, cpDBcc, MODE_IP, (Size)0, CpDbcc, CIMS)
         }
 
+        
         //
         // Memory management unit
         //
@@ -1948,41 +1949,6 @@ Moira::createJumpTable(Model model, bool regDasm)
         }
 
 
-        //
-        // Floating point unit
-        //
-
-        if (model == M68040) {
-
-            opcode = parse("1111 0010 100- ----");
-            ___________XXXXX(opcode, FBcc, MODE_IP, Word, FBcc, CIMS)
-
-            opcode = parse("1111 0010 110- ----");
-            ___________XXXXX(opcode, FBcc, MODE_IP, Long, FBcc, CIMS)
-
-            opcode = parse("1111 0010 00-- ----");
-            __________XXXXXX(opcode, cpGEN, MODE_IP, Unsized, FGen, CIMS)
-            __________MMMXXX(opcode, cpGEN, 0b111111111111, Unsized, FGen, CIMS)
-
-            opcode = parse("1111 0011 01-- ----");
-            __________MMMXXX(opcode, FRESTORE, 0b001101111110, Word, FRestore, CIMS)
-
-            opcode = parse("1111 0011 00-- ----");
-            __________MMMXXX(opcode, FSAVE, 0b001011111000, Word, FSave, CIMS)
-
-            opcode = parse("1111 0010 0111 1---");
-            ________________(opcode | 0b010, FTRAPcc, MODE_IP, Word, FTrapcc, CIMS)
-            ________________(opcode | 0b011, FTRAPcc, MODE_IP, Long, FTrapcc, CIMS)
-            ________________(opcode | 0b100, FTRAPcc, MODE_IP, Unsized, FTrapcc, CIMS)
-
-            opcode = parse("1111 0010 01-- ----");
-            __________MMMXXX(opcode, FScc, 0b101111111000, Byte, FScc, CIMS)
-
-            opcode = parse("1111 0010 0100 1---");
-            _____________XXX(opcode, FDBcc, MODE_IP, Word, FDbcc, CIMS)
-        }
-
-
         //
         // 68040 instructions
         //
@@ -2030,4 +1996,38 @@ Moira::createJumpTable(Model model, bool regDasm)
             _____________XXX(opcode, MOVE16, MODE_IP, Unsized, Move16AlAi, CIMS)
         }
     }
+
+    //
+    // Floating-Point Unit
+    //
+
+    if (model == M68040 || has6888x()) {
+
+        opcode = parse("1111 0010 100- ----");
+        ___________XXXXX(opcode, FBcc, MODE_IP, Word, FBcc, CIMS)
+
+        opcode = parse("1111 0010 110- ----");
+        ___________XXXXX(opcode, FBcc, MODE_IP, Long, FBcc, CIMS)
+
+        opcode = parse("1111 0010 00-- ----");
+        __________XXXXXX(opcode, cpGEN, MODE_IP, Unsized, FGen, CIMS)
+        __________MMMXXX(opcode, cpGEN, 0b111111111111, Unsized, FGen, CIMS)
+
+        opcode = parse("1111 0011 01-- ----");
+        __________MMMXXX(opcode, FRESTORE, 0b001101111110, Word, FRestore, CIMS)
+
+        opcode = parse("1111 0011 00-- ----");
+        __________MMMXXX(opcode, FSAVE, 0b001011111000, Word, FSave, CIMS)
+
+        opcode = parse("1111 0010 0111 1---");
+        ________________(opcode | 0b010, FTRAPcc, MODE_IP, Word, FTrapcc, CIMS)
+        ________________(opcode | 0b011, FTRAPcc, MODE_IP, Long, FTrapcc, CIMS)
+        ________________(opcode | 0b100, FTRAPcc, MODE_IP, Unsized, FTrapcc, CIMS)
+
+        opcode = parse("1111 0010 01-- ----");
+        __________MMMXXX(opcode, FScc, 0b101111111000, Byte, FScc, CIMS)
+
+        opcode = parse("1111 0010 0100 1---");
+        _____________XXX(opcode, FDBcc, MODE_IP, Word, FDbcc, CIMS)
+    }
 }
diff --git a/Emulator/Components/CPU/Moira/MoiraTypes.h b/Emulator/Components/CPU/Moira/MoiraTypes.h
index 9a7723935..df72821ba 100644
--- a/Emulator/Components/CPU/Moira/MoiraTypes.h
+++ b/Emulator/Components/CPU/Moira/MoiraTypes.h
@@ -47,6 +47,14 @@ typedef enum
 }
 Model;
 
+typedef enum
+{
+    INTERNAL_FPU,           // Built-in FPU (in any)
+    M68881,                 // Floating-point coprocessor
+    M68882                  // Floating-point coprocessor
+}
+FPUModel;
+
 typedef enum
 {
     C68000,                 // Used by M68000
@@ -160,10 +168,13 @@ RegName;
 
 typedef enum
 {
-    Unsized = 0,
-    Byte    = 1,            // .b : Byte addressing
-    Word    = 2,            // .w : Word addressing
-    Long    = 4             // .l : Long word addressing
+    Unsized     = 0,
+    Byte        = 1,        // .b : Byte addressing
+    Word        = 2,        // .w : Word addressing
+    Long        = 4,        // .l : Long word addressing
+
+    Quad        = 8,        // FPU
+    Extended    = 12        // FPU
 }
 Size;
 
@@ -254,13 +265,45 @@ typedef enum
 }
 MemSpace;
 
-/* TODO:
+typedef enum
+{
+    FLT_LONG,
+    FLT_SINGLE,
+    FLT_EXTENDED,
+    FLT_PACKED,
+    FLT_WORD,
+    FLT_DOUBLE,
+    FLT_BYTE
+}
+FltFormat;
+
+typedef enum
+{
+    FPU_PREC_EXTENDED,
+    FPU_PREC_SINGLE,
+    FPU_PREC_DOUBLE,
+    FPU_PREC_UNDEFINED
+}
+FpuPrecision;
 
- typedef enum
- {
- }
- FSize;
- */
+typedef enum
+{
+    FPU_RND_NEAREST,
+    FPU_RND_ZERO,
+    FPU_RND_DOWNWARD,
+    FPU_RND_UPWARD
+}
+FpuRoundingMode;
+
+typedef enum
+{
+    FPU_FRAME_INVALID,
+    FPU_FRAME_NULL,
+    FPU_FRAME_IDLE,
+    FPU_FRAME_UNIMP,
+    FPU_FRAME_BUSY,
+}
+FpuFrameType;
 
 
 //
@@ -335,19 +378,6 @@ struct PrefetchQueue {
     u16 ird;                // The instruction currently being executed
 };
 
-struct Float80 {
-
-    softfloat::floatx80 raw;
-};
-
-struct FPU {
-
-    Float80 fpr[8];
-    u32 fpiar;
-    u32 fpsr;
-    u32 fpcr;
-};
-
 struct InstrInfo
 {
     Instr I;
@@ -382,6 +412,22 @@ static constexpr u8 FC_USER_PROG        = 2;
 static constexpr u8 FC_SUPERVISOR_DATA  = 5;
 static constexpr u8 FC_SUPERVISOR_PROG  = 6;
 
+// Floating-point condition codes
+static constexpr u32 FPCC_N             = 1 << 27;
+static constexpr u32 FPCC_Z             = 1 << 26;
+static constexpr u32 FPCC_I             = 1 << 25;
+static constexpr u32 FPCC_NAN           = 1 << 24;
+
+// Floating-point exception bits
+static constexpr u32 FPEXP_BSUN         = 1 << 15;
+static constexpr u32 FPEXP_SNAN         = 1 << 14;
+static constexpr u32 FPEXP_OPERR        = 1 << 13;
+static constexpr u32 FPEXP_OVFL         = 1 << 12;
+static constexpr u32 FPEXP_UNFL         = 1 << 11;
+static constexpr u32 FPEXP_DZ           = 1 << 10;
+static constexpr u32 FPEXP_INEX2        = 1 << 9;
+static constexpr u32 FPEXP_INEX1        = 1 << 8;
+
 // Availabilty masks
 static constexpr u16 AV_68000           = 1 << M68000;
 static constexpr u16 AV_68010           = 1 << M68010;
@@ -474,6 +520,9 @@ static constexpr u64 AE_SET_IF      = (1 << 13);  // Set bit 13 in the special s
 // Timing flags
 static constexpr u64 IMPL_DEC       = (1 << 14);  // Omit 2 cycle delay in -(An) mode
 
+// FPU
+static constexpr u64 FPU_FMOVEM     = (1 << 15);  // Experimental
+
 
 //
 // Exceptions
@@ -485,6 +534,7 @@ struct AddressError : public std::exception {
     AddressError(const StackFrame frame) { stackFrame = frame; }
 };
 
+struct IllegalInstruction : public std::exception { };
 struct BusErrorException : public std::exception { };
 struct DoubleFault : public std::exception { };
 
diff --git a/Emulator/Components/CPU/Moira/StrWriter.h b/Emulator/Components/CPU/Moira/StrWriter.h
index 6b5bbd5f6..cbf399f26 100644
--- a/Emulator/Components/CPU/Moira/StrWriter.h
+++ b/Emulator/Components/CPU/Moira/StrWriter.h
@@ -2,9 +2,7 @@
 // This file is part of Moira - A Motorola 68k emulator
 //
 // Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
-// Licensed under the GNU General Public License v3
-//
-// See https://www.gnu.org for license information
+// Published under the terms of the MIT License
 // -----------------------------------------------------------------------------
 
 #pragma once
@@ -24,8 +22,8 @@ struct UInt24 { u32 raw; UInt24(u32 v) : raw(v) { } };
 struct UInt32 { u32 raw; UInt32(u32 v) : raw(v) { } };
 
 // Immediate operands
-struct Imu { u32 raw; Imu(u32 v) : raw(v) { } };
-template <Size S> struct Ims { i32 raw; Ims(i32 v) : raw(v) { } };
+template <Size S = Long> struct Imu { u32 raw; Imu(u32 v) : raw(v) { } };
+template <Size S = Long> struct Ims { i32 raw; Ims(i32 v) : raw(v) { } };
 struct Imd { u32 raw; Imd(u32 v) : raw(v) { } };
 
 // Mnemonics
@@ -124,7 +122,7 @@ class StrWriter
     StrWriter& operator<<(UInt24);
     StrWriter& operator<<(UInt32);
 
-    StrWriter& operator<<(Imu);
+    template <Size S> StrWriter& operator<<(Imu<S>);
     template <Size S> StrWriter& operator<<(Ims<S>);
     StrWriter& operator<<(Imd);
 
diff --git a/Emulator/Components/CPU/Moira/StrWriter_cpp.h b/Emulator/Components/CPU/Moira/StrWriter_cpp.h
index a87965249..2a90c9204 100644
--- a/Emulator/Components/CPU/Moira/StrWriter_cpp.h
+++ b/Emulator/Components/CPU/Moira/StrWriter_cpp.h
@@ -2,9 +2,7 @@
 // This file is part of Moira - A Motorola 68k emulator
 //
 // Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
-// Licensed under the GNU General Public License v3
-//
-// See https://www.gnu.org for license information
+// Published under the terms of the MIT License
 // -----------------------------------------------------------------------------
 
 #include <cmath>
@@ -219,11 +217,11 @@ StrWriter::operator<<(UInt32 u)
     return *this;
 }
 
-StrWriter&
-StrWriter::operator<<(Imu im)
+template <Size S> StrWriter&
+StrWriter::operator<<(Imu<S> im)
 {
     *ptr++ = '#';
-    *this << UInt(im.raw);
+    *this << UInt(CLIP<S>(im.raw));
     return *this;
 }
 
@@ -1231,7 +1229,7 @@ StrWriter::operator<<(Im<M, S> wrapper)
 
         default:
 
-            *this << Imu(ea.ext1);
+            *this << Imu<S>(ea.ext1);
             break;
     }
 
@@ -1358,7 +1356,7 @@ StrWriter::operator<<(Fp fp)
 StrWriter&
 StrWriter::operator<<(Ffmt ffmt)
 {
-    if (style.syntax != DASM_MOIRA_MIT && style.syntax != DASM_GNU_MIT) *ptr++ = '.';
+    if (style.syntax != DASM_GNU && style.syntax != DASM_GNU_MIT) *ptr++ = '.';
 
     switch (ffmt.raw) {
 
diff --git a/Emulator/Components/CPU/Moira/softfloat/softfloat.h b/Emulator/Components/CPU/Moira/softfloat/softfloat.h
index 5f66060f7..cd9013f27 100644
--- a/Emulator/Components/CPU/Moira/softfloat/softfloat.h
+++ b/Emulator/Components/CPU/Moira/softfloat/softfloat.h
@@ -41,6 +41,8 @@ these four paragraphs for those parts of this code that are retained.
 
 namespace softfloat {
 
+extern flag floatx80_is_nan( floatx80 a ); // DIRK: ADDED
+
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE floating-point underflow tininess-detection mode.
 *----------------------------------------------------------------------------*/
diff --git a/Emulator/Media/RomFiles/RomFile.cpp b/Emulator/Media/RomFiles/RomFile.cpp
index b598aa43f..945a16698 100644
--- a/Emulator/Media/RomFiles/RomFile.cpp
+++ b/Emulator/Media/RomFiles/RomFile.cpp
@@ -107,6 +107,7 @@ RomFile::isDiagRom(u32 crc32)
         case CRC32_DIAG11:
         case CRC32_DIAG12:
         case CRC32_DIAG121:
+        case CRC32_DIAG13:
         case CRC32_LOGICA20: return true;
 
         default: return false;
@@ -273,6 +274,7 @@ RomFile::shortName(u32 crc32)
         case CRC32_DIAG11:                  return "DiagROM 1.1";
         case CRC32_DIAG12:                  return "DiagROM 1.2";
         case CRC32_DIAG121:                 return "DiagROM 1.2.1";
+        case CRC32_DIAG13:                  return "DiagROM 1.3";
         case CRC32_LOGICA20:                return "Logica Diagnostic 2.0";
 
         default:
@@ -354,7 +356,8 @@ RomFile::title(u32 crc32)
 
         case CRC32_DIAG11:
         case CRC32_DIAG12:
-        case CRC32_DIAG121:                 return "Amiga DiagROM";
+        case CRC32_DIAG121:
+        case CRC32_DIAG13 :                 return "Amiga DiagROM";
         case CRC32_LOGICA20:                return "Logica Diagnostic";
 
         default:                            return "Unknown or patched Rom";
@@ -437,6 +440,7 @@ RomFile::version(u32 crc32)
         case CRC32_DIAG11:                  return "Version 1.1";
         case CRC32_DIAG12:                  return "Version 1.2";
         case CRC32_DIAG121:                 return "Version 1.2.1";
+        case CRC32_DIAG13:                  return "Version 1.3";
         case CRC32_LOGICA20:                return "Version 2.0";
 
         default:
@@ -519,6 +523,7 @@ RomFile::released(u32 crc32)
         case CRC32_DIAG11:                  return "October 2018";
         case CRC32_DIAG12:                  return "August 2019";
         case CRC32_DIAG121:                 return "July 2020";
+        case CRC32_DIAG13:                  return "April 2023";
         case CRC32_LOGICA20:                return "";
 
         default:                            return "";
@@ -600,6 +605,7 @@ RomFile::model(u32 crc32)
         case CRC32_DIAG11:                  return "";
         case CRC32_DIAG12:                  return "";
         case CRC32_DIAG121:                 return "";
+        case CRC32_DIAG13:                  return "";
         case CRC32_LOGICA20:                return "";
 
         default:                            return "";
diff --git a/Emulator/Media/RomFiles/RomFileTypes.h b/Emulator/Media/RomFiles/RomFileTypes.h
index ae1e049b1..0e2b93fad 100644
--- a/Emulator/Media/RomFiles/RomFileTypes.h
+++ b/Emulator/Media/RomFiles/RomFileTypes.h
@@ -86,4 +86,5 @@ static const u32 CRC32_AROS_1ED13DE6E3_EXT      = 0xF2A9CDC5;
 static const u32 CRC32_DIAG11                   = 0x4C4B5C05;
 static const u32 CRC32_DIAG12                   = 0x771CD0EA;
 static const u32 CRC32_DIAG121                  = 0x850209CD;
+static const u32 CRC32_DIAG13                   = 0x55E2E127;
 static const u32 CRC32_LOGICA20                 = 0x8484F426;
diff --git a/Emulator/Misc/RetroShell/InterpreterCmds.cpp b/Emulator/Misc/RetroShell/InterpreterCmds.cpp
index 71fd98781..7dbf46af4 100644
--- a/Emulator/Misc/RetroShell/InterpreterCmds.cpp
+++ b/Emulator/Misc/RetroShell/InterpreterCmds.cpp
@@ -392,6 +392,16 @@ Interpreter::initCommandShell(Command &root)
         amiga.configure(OPT_CPU_REVISION, parseEnum <CPURevisionEnum> (argv));
     });
 
+    if (amiga.fpuSupport()) {
+
+        root.add({"cpu", "set", "fpu"}, { FPURevisionEnum::argList() },
+                 "Selects the emulated floating-point unit",
+                 [this](Arguments& argv, long value) {
+
+            amiga.configure(OPT_FPU_REVISION, parseEnum <FPURevisionEnum> (argv));
+        });
+    }
+
     root.add({"cpu", "set", "dasm"},
              "Configures the disassembler");
 
diff --git a/Emulator/Misc/RetroShell/InterpreterDebugCmds.cpp b/Emulator/Misc/RetroShell/InterpreterDebugCmds.cpp
index cca45c2ba..df15e299e 100644
--- a/Emulator/Misc/RetroShell/InterpreterDebugCmds.cpp
+++ b/Emulator/Misc/RetroShell/InterpreterDebugCmds.cpp
@@ -85,6 +85,7 @@ Interpreter::initDebugShell(Command &root)
     root.add({"amiga"},         "Main computer");
     root.add({"memory"},        "RAM and ROM");
     root.add({"cpu"},           "Motorola 68k CPU");
+    if (amiga.fpuSupport()) root.add({"fpu"}, "Floating-point unit");
     root.add({"ciaa"},          "Complex Interface Adapter A");
     root.add({"ciab"},          "Complex Interface Adapter B");
     root.add({"agnus"},         "Custom Chipset");
@@ -448,6 +449,20 @@ Interpreter::initDebugShell(Command &root)
         retroShell.dump(cpu, Category::Vectors);
     });
 
+    
+    //
+    // FPU
+    //
+
+    if (amiga.fpuSupport()) {
+
+        root.add({"fpu", ""},
+                 "Inspects the internal state",
+                 [this](Arguments& argv, long value) {
+
+            retroShell.dump(cpu, Category::Fpu);
+        });
+    }
 
     //
     // CIA
diff --git a/Emulator/Utilities/Serialization.h b/Emulator/Utilities/Serialization.h
index 68d2e7eed..b612fbd43 100644
--- a/Emulator/Utilities/Serialization.h
+++ b/Emulator/Utilities/Serialization.h
@@ -12,6 +12,7 @@
 #include "Macros.h"
 #include "MemUtils.h"
 #include "Buffer.h"
+#include <cassert>
 #include <vector>
 
 namespace util {
@@ -95,7 +96,6 @@ inline void writeDouble(u8 *& buf, double value)
 inline void writeString(u8 *& buf, string value)
 {
     auto len = value.length();
-    assert(len < 256);
     write8(buf, u8(len));
     value.copy((char *)buf, len);
     buf += len;
diff --git a/Emulator/config.h b/Emulator/config.h
index e3ce8c9e8..cdc31475a 100644
--- a/Emulator/config.h
+++ b/Emulator/config.h
@@ -26,7 +26,7 @@
 #define SNP_BETA 0
 
 // Uncomment this setting in a release build
-#define RELEASEBUILD
+// #define RELEASEBUILD
 
 
 //
@@ -103,6 +103,7 @@
 static const int NO_SEQ_FASTPATH = 0; // Disable sequencer fast path
 static const int NO_BPL_FASTPATH = 0; // Disable drawing fast path
 static const int DIAG_BOARD      = 0; // Plug in the diagnose board
+static const int FPU_SUPPORT     = 0; // Enable FPU (not working yet)
 
 
 //
diff --git a/GUI/Defaults.swift b/GUI/Defaults.swift
index ad2a8528d..7da858b08 100644
--- a/GUI/Defaults.swift
+++ b/GUI/Defaults.swift
@@ -685,6 +685,7 @@ extension DefaultsProxy {
 
         remove(.VIDEO_FORMAT)
         remove(.CPU_REVISION)
+        remove(.FPU_REVISION)
         remove(.CPU_OVERCLOCKING)
         remove(.WARP_MODE)
         remove(.AGNUS_REVISION)
@@ -705,6 +706,7 @@ extension Configuration {
 
         machineType = defaults.get(.VIDEO_FORMAT)
         cpuRev = defaults.get(.CPU_REVISION)
+        fpuRev = defaults.get(.FPU_REVISION)
         cpuSpeed = defaults.get(.CPU_OVERCLOCKING)
         warpMode = defaults.get(.WARP_MODE)
         agnusRev = defaults.get(.AGNUS_REVISION)
@@ -724,6 +726,7 @@ extension Configuration {
 
         defaults.set(.VIDEO_FORMAT, machineType)
         defaults.set(.CPU_REVISION, cpuRev)
+        defaults.set(.FPU_REVISION, fpuRev)
         defaults.set(.CPU_OVERCLOCKING, cpuSpeed)
         defaults.set(.WARP_MODE, warpMode)
         defaults.set(.AGNUS_REVISION, agnusRev)
diff --git a/GUI/Dialogs/Configuration/ChipsetConf.swift b/GUI/Dialogs/Configuration/ChipsetConf.swift
index b2107b357..553c5afe2 100644
--- a/GUI/Dialogs/Configuration/ChipsetConf.swift
+++ b/GUI/Dialogs/Configuration/ChipsetConf.swift
@@ -42,7 +42,7 @@ extension ConfigurationController {
 
         case ._68030:
             csCpuInfo1.stringValue = "Motorola MC68030"
-            csCpuInfo2.stringValue = ""
+            csCpuInfo2.stringValue = "A3000"
 
         case ._68EC040:
             csCpuInfo1.stringValue = "Motorola 68EC040"
@@ -62,6 +62,42 @@ extension ConfigurationController {
             csCpuInfo2.stringValue = ""
         }
 
+        // FPU
+        if amiga.fpuSupport {
+
+            csFpuRevision.selectItem(withTag: config.fpuRev)
+            switch FPURevision(rawValue: config.fpuRev) {
+
+            case ._INTERNAL:
+                csFpuInfo1.stringValue = ""
+                csFpuInfo2.stringValue = ""
+                csFpuIcon.isHidden = true
+
+            case ._68881:
+                csFpuInfo1.stringValue = "Motorola MC68881"
+                csFpuInfo2.stringValue = "Floating-Point Coprocessor"
+                csFpuIcon.isHidden = false
+
+            case ._68882:
+                csFpuInfo1.stringValue = "Motorola MC68882"
+                csFpuInfo2.stringValue = "Floating-Point Coprocessor"
+                csFpuIcon.isHidden = false
+
+            default:
+                csFpuInfo1.stringValue = "Invalid"
+                csFpuInfo2.stringValue = ""
+                csFpuIcon.isHidden = false
+            }
+
+        } else {
+
+            csFpuLabel.isHidden = true
+            csFpuRevision.isHidden = true
+            csFpuInfo1.isHidden = true
+            csFpuInfo2.isHidden = true
+            csFpuIcon.isHidden = true
+        }
+
         // Warp
         csWarpMode.selectItem(withTag: config.warpMode)
 
@@ -179,6 +215,12 @@ extension ConfigurationController {
         refresh()
     }
 
+    @IBAction func csFpuRevAction(_ sender: NSPopUpButton!) {
+
+        config.fpuRev = sender.selectedTag()
+        refresh()
+    }
+
     @IBAction func csWarpModeAction(_ sender: NSPopUpButton!) {
 
         config.warpMode = sender.selectedTag()
diff --git a/GUI/Dialogs/Configuration/Configuration.swift b/GUI/Dialogs/Configuration/Configuration.swift
index fffed3842..4fb4201ae 100644
--- a/GUI/Dialogs/Configuration/Configuration.swift
+++ b/GUI/Dialogs/Configuration/Configuration.swift
@@ -43,6 +43,10 @@ class Configuration {
         get { return amiga.getConfig(.CPU_REVISION) }
         set { amiga.configure(.CPU_REVISION, value: newValue) }
     }
+    var fpuRev: Int {
+        get { return amiga.getConfig(.FPU_REVISION) }
+        set { amiga.configure(.FPU_REVISION, value: newValue) }
+    }
     var cpuDasmRev: Int {
         get { return amiga.getConfig(.CPU_DASM_REVISION) }
         set { amiga.configure(.CPU_DASM_REVISION, value: newValue) }
diff --git a/GUI/Dialogs/Configuration/ConfigurationController.swift b/GUI/Dialogs/Configuration/ConfigurationController.swift
index 66f3c451f..11f1736f4 100644
--- a/GUI/Dialogs/Configuration/ConfigurationController.swift
+++ b/GUI/Dialogs/Configuration/ConfigurationController.swift
@@ -61,6 +61,13 @@ class ConfigurationController: DialogController {
     @IBOutlet weak var csCpuInfo1: NSTextField!
     @IBOutlet weak var csCpuInfo2: NSTextField!
 
+    // FPU
+    @IBOutlet weak var csFpuLabel: NSTextField!
+    @IBOutlet weak var csFpuRevision: NSPopUpButton!
+    @IBOutlet weak var csFpuInfo1: NSTextField!
+    @IBOutlet weak var csFpuInfo2: NSTextField!
+    @IBOutlet weak var csFpuIcon: NSButton!
+
     // Warp
     @IBOutlet weak var csWarpMode: NSPopUpButton!
 
diff --git a/GUI/Dialogs/Configuration/RomConf.swift b/GUI/Dialogs/Configuration/RomConf.swift
index 8ad6c5c0c..e773706a7 100644
--- a/GUI/Dialogs/Configuration/RomConf.swift
+++ b/GUI/Dialogs/Configuration/RomConf.swift
@@ -121,7 +121,7 @@ extension ConfigurationController {
 
             switch UInt32(item.tag) {
 
-            case CRC32_AROS_54705, CRC32_AROS_55696, CRC32_DIAG121:
+            case CRC32_AROS_54705, CRC32_AROS_55696, CRC32_DIAG121, CRC32_DIAG13:
                 item.isEnabled = true
 
             default:
@@ -176,6 +176,9 @@ extension ConfigurationController {
         case CRC32_DIAG121:
             install(rom: "diagrom-121")
 
+        case CRC32_DIAG13:
+            install(rom: "diagrom-13")
+
         default:
             if let url = UserDefaults.romUrl(fingerprint: crc32) {
                 try? amiga.mem.loadRom(url)
diff --git a/GUI/XIB files/Configuration.xib b/GUI/XIB files/Configuration.xib
index 5245280b5..54a5ced1f 100644
--- a/GUI/XIB files/Configuration.xib	
+++ b/GUI/XIB files/Configuration.xib	
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="21507" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct">
+<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="22155" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct">
     <dependencies>
         <deployment identifier="macosx"/>
-        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="21507"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="22155"/>
         <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
     </dependencies>
     <objects>
@@ -64,6 +64,11 @@
                 <outlet property="csDeniseInfo2" destination="foW-bH-7Vf" id="kjx-CM-t1P"/>
                 <outlet property="csDeniseRevision" destination="M5c-fi-zMW" id="hMq-Cn-E1U"/>
                 <outlet property="csFactorySettingsPopup" destination="uR2-36-afT" id="1p8-wv-b9a"/>
+                <outlet property="csFpuIcon" destination="sge-VF-FP1" id="qma-cY-zSP"/>
+                <outlet property="csFpuInfo1" destination="1I6-WD-ast" id="vOl-VQ-vhD"/>
+                <outlet property="csFpuInfo2" destination="qV2-9l-eZm" id="c0B-B3-727"/>
+                <outlet property="csFpuLabel" destination="k6x-1F-wwn" id="6FW-0J-hKR"/>
+                <outlet property="csFpuRevision" destination="57X-NK-zUX" id="lg1-PW-sPn"/>
                 <outlet property="csLockImage" destination="nxr-43-cIJ" id="ElE-Ga-2uJ"/>
                 <outlet property="csLockInfo1" destination="DDQ-1d-Teh" id="ABA-0a-Oku"/>
                 <outlet property="csLockInfo2" destination="dpR-tS-CiI" id="lqK-OQ-5fr"/>
@@ -499,7 +504,7 @@ DQ
                                         <popUpButton verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="b1E-it-StT">
                                             <rect key="frame" x="9" y="8" width="128" height="25"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
-                                            <popUpButtonCell key="cell" type="push" title="Install Rom..." bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="borderAndBezel" imageScaling="proportionallyDown" inset="2" pullsDown="YES" autoenablesItems="NO" selectedItem="h2O-8a-diy" id="Q5u-S4-ml0">
+                                            <popUpButtonCell key="cell" type="push" title="Install Rom..." bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="borderAndBezel" imageScaling="proportionallyDown" inset="2" pullsDown="YES" autoenablesItems="NO" id="Q5u-S4-ml0">
                                                 <behavior key="behavior" lightByBackground="YES" lightByGray="YES"/>
                                                 <font key="font" metaFont="menu"/>
                                                 <menu key="menu" autoenablesItems="NO" id="kL0-2m-Gp7">
@@ -531,6 +536,9 @@ DQ
                                                         <menuItem title="DiagRom 1.2.1" image="chipTemplate" tag="2231503309" id="kib-Jn-TWF">
                                                             <modifierMask key="keyEquivalentModifierMask"/>
                                                         </menuItem>
+                                                        <menuItem title="DiagRom 1.3" image="chipTemplate" tag="1440932135" id="fs2-mW-lH7">
+                                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                                        </menuItem>
                                                         <menuItem title="Logica Diagnostic Rom 2.0" image="chipTemplate" tag="2223305766" id="wOf-rE-Ey3">
                                                             <modifierMask key="keyEquivalentModifierMask"/>
                                                         </menuItem>
@@ -550,7 +558,7 @@ DQ
                                     <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
                                     <subviews>
                                         <popUpButton fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="dyR-Jf-UoN" userLabel="System">
-                                            <rect key="frame" x="70" y="373" width="152" height="25"/>
+                                            <rect key="frame" x="70" y="373" width="156" height="25"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="68000" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="1vX-aH-r8M" id="0Rz-Gs-GNL" userLabel="System">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -559,7 +567,7 @@ DQ
                                                     <items>
                                                         <menuItem title="68000" state="on" id="1vX-aH-r8M"/>
                                                         <menuItem title="68010" tag="1" id="U9p-JK-c4z"/>
-                                                        <menuItem title="68EC020 (Beta)" tag="2" id="MEV-jP-nPJ"/>
+                                                        <menuItem title="68EC020" tag="2" id="MEV-jP-nPJ"/>
                                                         <menuItem title="68020" tag="3" hidden="YES" id="TvX-YB-qqk"/>
                                                         <menuItem title="68EC030" tag="4" hidden="YES" id="M9J-fS-CSl"/>
                                                         <menuItem title="68030" tag="5" hidden="YES" id="rTV-fK-bQq"/>
@@ -659,7 +667,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="NhV-6L-1Lz">
-                                            <rect key="frame" x="32" y="138" width="36" height="16"/>
+                                            <rect key="frame" x="32" y="128" width="36" height="16"/>
                                             <autoresizingMask key="autoresizingMask"/>
                                             <textFieldCell key="cell" lineBreakMode="clipping" alignment="right" title="CIAs:" id="4rw-Nl-iMO">
                                                 <font key="font" metaFont="system"/>
@@ -668,7 +676,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <popUpButton fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="jPQ-4k-CcG" userLabel="System">
-                                            <rect key="frame" x="69" y="132" width="152" height="25"/>
+                                            <rect key="frame" x="70" y="122" width="156" height="25"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="DIP" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="wbu-fM-hZz" id="DjN-H6-9zb" userLabel="System">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -721,7 +729,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="GeO-sm-MdC">
-                                            <rect key="frame" x="359" y="140" width="34" height="16"/>
+                                            <rect key="frame" x="359" y="130" width="34" height="16"/>
                                             <autoresizingMask key="autoresizingMask"/>
                                             <textFieldCell key="cell" lineBreakMode="clipping" alignment="right" title="RTC:" id="CKa-bU-esp">
                                                 <font key="font" metaFont="system"/>
@@ -730,7 +738,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="yt8-wX-EDv">
-                                            <rect key="frame" x="343" y="260" width="50" height="16"/>
+                                            <rect key="frame" x="343" y="240" width="50" height="16"/>
                                             <autoresizingMask key="autoresizingMask"/>
                                             <textFieldCell key="cell" lineBreakMode="clipping" alignment="right" title="Denise:" id="PWh-b6-VcK">
                                                 <font key="font" metaFont="system"/>
@@ -739,7 +747,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <popUpButton fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="M5c-fi-zMW" userLabel="System">
-                                            <rect key="frame" x="395" y="253" width="156" height="25"/>
+                                            <rect key="frame" x="395" y="233" width="156" height="25"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="OCS" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="6ZC-38-juZ" id="mxV-ez-x7L" userLabel="System">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -756,7 +764,7 @@ DQ
                                             </connections>
                                         </popUpButton>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="667-IR-WbK">
-                                            <rect key="frame" x="443" y="230" width="149" height="16"/>
+                                            <rect key="frame" x="443" y="210" width="149" height="16"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" lineBreakMode="clipping" title="Lorem Ipsum" id="8FK-ke-dQF">
                                                 <font key="font" usesAppearanceFont="YES"/>
@@ -765,7 +773,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="foW-bH-7Vf">
-                                            <rect key="frame" x="443" y="213" width="149" height="14"/>
+                                            <rect key="frame" x="443" y="193" width="149" height="14"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" controlSize="small" lineBreakMode="clipping" title="Lorem Ipsum" id="LVF-yE-bgm">
                                                 <font key="font" metaFont="smallSystem"/>
@@ -774,7 +782,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <popUpButton fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="3nw-g4-iBc" userLabel="System">
-                                            <rect key="frame" x="395" y="133" width="156" height="25"/>
+                                            <rect key="frame" x="395" y="123" width="156" height="25"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="None" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="aJJ-Yq-h7E" id="HpG-tg-azQ" userLabel="System">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -792,7 +800,7 @@ DQ
                                             </connections>
                                         </popUpButton>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="Wyd-E9-HnG">
-                                            <rect key="frame" x="443" y="110" width="149" height="16"/>
+                                            <rect key="frame" x="443" y="100" width="149" height="16"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" lineBreakMode="clipping" title="Lorem Ipsum" id="cle-nY-l0d">
                                                 <font key="font" usesAppearanceFont="YES"/>
@@ -801,7 +809,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="kSc-45-2Mv">
-                                            <rect key="frame" x="443" y="93" width="149" height="14"/>
+                                            <rect key="frame" x="443" y="83" width="149" height="14"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" controlSize="small" lineBreakMode="clipping" title="Lorem Ipsum" id="6pr-Hy-ZYf">
                                                 <font key="font" metaFont="smallSystem"/>
@@ -818,7 +826,7 @@ DQ
                                             </buttonCell>
                                         </button>
                                         <popUpButton fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="PgV-ga-20g" userLabel="System">
-                                            <rect key="frame" x="223" y="373" width="89" height="25"/>
+                                            <rect key="frame" x="227" y="373" width="89" height="25"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="7 MHz" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="crx-06-qxi" id="YyS-kP-Noo" userLabel="System">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -840,7 +848,7 @@ DQ
                                             </connections>
                                         </popUpButton>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="Wja-UH-znD">
-                                            <rect key="frame" x="21" y="259" width="46" height="16"/>
+                                            <rect key="frame" x="21" y="239" width="46" height="16"/>
                                             <autoresizingMask key="autoresizingMask"/>
                                             <textFieldCell key="cell" lineBreakMode="clipping" alignment="right" title="Agnus:" id="A5h-uV-NaB">
                                                 <font key="font" metaFont="system"/>
@@ -849,7 +857,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <popUpButton fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="8N2-3Z-olH" userLabel="System">
-                                            <rect key="frame" x="70" y="253" width="152" height="25"/>
+                                            <rect key="frame" x="70" y="233" width="156" height="25"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="Early OCS" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="ljH-i4-bUR" id="fSc-ZT-ROw" userLabel="System">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -872,7 +880,7 @@ DQ
                                             </connections>
                                         </popUpButton>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="wLf-sj-Myk">
-                                            <rect key="frame" x="117" y="230" width="193" height="16"/>
+                                            <rect key="frame" x="117" y="210" width="193" height="16"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" lineBreakMode="clipping" title="Lorem Ipsum" id="MeP-cU-7kO">
                                                 <font key="font" usesAppearanceFont="YES"/>
@@ -881,7 +889,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="XLM-HY-hK6">
-                                            <rect key="frame" x="117" y="213" width="193" height="14"/>
+                                            <rect key="frame" x="117" y="193" width="193" height="14"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" controlSize="small" lineBreakMode="clipping" title="Lorem Ipsum" id="LM9-bv-G3c">
                                                 <font key="font" metaFont="smallSystem"/>
@@ -890,7 +898,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <button fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="2OQ-RC-DM7">
-                                            <rect key="frame" x="72" y="207" width="41" height="39"/>
+                                            <rect key="frame" x="72" y="187" width="41" height="39"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="square" bezelStyle="shadowlessSquare" image="rom_medium" imagePosition="only" alignment="center" imageScaling="proportionallyUpOrDown" inset="2" id="iSw-rM-Ad8">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -898,15 +906,68 @@ DQ
                                             </buttonCell>
                                         </button>
                                         <button fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="SZi-4Q-Pp3">
-                                            <rect key="frame" x="398" y="207" width="41" height="39"/>
+                                            <rect key="frame" x="398" y="187" width="41" height="39"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="square" bezelStyle="shadowlessSquare" image="rom_medium" imagePosition="only" alignment="center" imageScaling="proportionallyUpOrDown" inset="2" id="8Cj-HA-u7G">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
                                                 <font key="font" metaFont="system"/>
                                             </buttonCell>
                                         </button>
+                                        <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="k6x-1F-wwn">
+                                            <rect key="frame" x="360" y="380" width="33" height="16"/>
+                                            <autoresizingMask key="autoresizingMask"/>
+                                            <textFieldCell key="cell" lineBreakMode="clipping" alignment="right" title="CoP:" id="9Nv-bH-f0V">
+                                                <font key="font" metaFont="system"/>
+                                                <color key="textColor" name="labelColor" catalog="System" colorSpace="catalog"/>
+                                                <color key="backgroundColor" name="textBackgroundColor" catalog="System" colorSpace="catalog"/>
+                                            </textFieldCell>
+                                        </textField>
+                                        <popUpButton fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="57X-NK-zUX" userLabel="System">
+                                            <rect key="frame" x="395" y="373" width="156" height="25"/>
+                                            <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
+                                            <popUpButtonCell key="cell" type="push" title="None" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="Mxl-q6-IY6" id="V7o-QL-KVt" userLabel="System">
+                                                <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                                                <font key="font" metaFont="menu"/>
+                                                <menu key="menu" id="QQB-O0-24Y">
+                                                    <items>
+                                                        <menuItem title="None" state="on" id="Mxl-q6-IY6"/>
+                                                        <menuItem title="68881" tag="1" id="G6Z-0t-bZP"/>
+                                                        <menuItem title="68882" tag="2" id="vbv-cU-0YL"/>
+                                                    </items>
+                                                </menu>
+                                            </popUpButtonCell>
+                                            <connections>
+                                                <action selector="csFpuRevAction:" target="-2" id="mhK-XA-hlr"/>
+                                            </connections>
+                                        </popUpButton>
+                                        <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="1I6-WD-ast">
+                                            <rect key="frame" x="443" y="350" width="149" height="16"/>
+                                            <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                                            <textFieldCell key="cell" lineBreakMode="clipping" title="Lorem Ipsum" id="a3r-XT-GbN">
+                                                <font key="font" usesAppearanceFont="YES"/>
+                                                <color key="textColor" name="labelColor" catalog="System" colorSpace="catalog"/>
+                                                <color key="backgroundColor" name="textBackgroundColor" catalog="System" colorSpace="catalog"/>
+                                            </textFieldCell>
+                                        </textField>
+                                        <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="qV2-9l-eZm">
+                                            <rect key="frame" x="443" y="333" width="149" height="14"/>
+                                            <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                                            <textFieldCell key="cell" controlSize="small" lineBreakMode="clipping" title="Lorem Ipsum" id="rvN-8b-56Q">
+                                                <font key="font" metaFont="smallSystem"/>
+                                                <color key="textColor" name="secondaryLabelColor" catalog="System" colorSpace="catalog"/>
+                                                <color key="backgroundColor" name="textBackgroundColor" catalog="System" colorSpace="catalog"/>
+                                            </textFieldCell>
+                                        </textField>
+                                        <button fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="sge-VF-FP1">
+                                            <rect key="frame" x="398" y="327" width="41" height="39"/>
+                                            <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                                            <buttonCell key="cell" type="square" bezelStyle="shadowlessSquare" image="rom_medium" imagePosition="only" alignment="center" imageScaling="proportionallyUpOrDown" inset="2" id="Wfv-S5-7MS">
+                                                <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                                                <font key="font" metaFont="system"/>
+                                            </buttonCell>
+                                        </button>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="JQK-X4-XhH">
-                                            <rect key="frame" x="118" y="110" width="192" height="16"/>
+                                            <rect key="frame" x="118" y="100" width="192" height="16"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" lineBreakMode="clipping" title="Lorem Ipsum" id="5xP-rm-Taq">
                                                 <font key="font" usesAppearanceFont="YES"/>
@@ -915,7 +976,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <textField horizontalHuggingPriority="251" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="sXA-NA-h9R">
-                                            <rect key="frame" x="118" y="93" width="194" height="14"/>
+                                            <rect key="frame" x="118" y="83" width="194" height="14"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" controlSize="small" lineBreakMode="clipping" title="Lorem Ipsum" id="h8E-Qd-q99">
                                                 <font key="font" metaFont="smallSystem"/>
@@ -924,7 +985,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <button fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="1vn-VG-4mI">
-                                            <rect key="frame" x="73" y="86" width="41" height="39"/>
+                                            <rect key="frame" x="73" y="76" width="41" height="39"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="square" bezelStyle="shadowlessSquare" image="rom_medium" imagePosition="only" alignment="center" imageScaling="proportionallyUpOrDown" inset="2" id="3ry-Is-qbC">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -932,7 +993,7 @@ DQ
                                             </buttonCell>
                                         </button>
                                         <button fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="O4z-MY-Gb2">
-                                            <rect key="frame" x="398" y="86" width="41" height="39"/>
+                                            <rect key="frame" x="398" y="76" width="41" height="39"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="square" bezelStyle="shadowlessSquare" image="rom_medium" imagePosition="only" alignment="center" imageScaling="proportionallyUpOrDown" inset="2" id="i3J-MT-qYk">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -940,15 +1001,15 @@ DQ
                                             </buttonCell>
                                         </button>
                                         <box verticalHuggingPriority="750" fixedFrame="YES" boxType="separator" translatesAutoresizingMaskIntoConstraints="NO" id="ePN-6M-uD2">
-                                            <rect key="frame" x="9" y="170" width="581" height="5"/>
+                                            <rect key="frame" x="9" y="164" width="581" height="5"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                         </box>
                                         <box verticalHuggingPriority="750" fixedFrame="YES" boxType="separator" translatesAutoresizingMaskIntoConstraints="NO" id="9hp-JV-Xbx">
-                                            <rect key="frame" x="10" y="290" width="581" height="5"/>
+                                            <rect key="frame" x="10" y="275" width="581" height="5"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                         </box>
                                         <popUpButton fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="0dC-Bp-GRH" userLabel="System">
-                                            <rect key="frame" x="223" y="253" width="91" height="25"/>
+                                            <rect key="frame" x="227" y="233" width="91" height="25"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="PAL" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="559-c9-gxY" id="YMd-SZ-Ded" userLabel="System">
                                                 <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
@@ -965,7 +1026,7 @@ DQ
                                             </connections>
                                         </popUpButton>
                                         <textField verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="vQq-lq-GBL">
-                                            <rect key="frame" x="314" y="376" width="81" height="20"/>
+                                            <rect key="frame" x="7" y="297" width="59" height="20"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <textFieldCell key="cell" refusesFirstResponder="YES" sendsActionOnEndEditing="YES" alignment="right" title="Warp:" id="Uqi-eB-NVQ">
                                                 <font key="font" metaFont="system"/>
@@ -974,7 +1035,7 @@ DQ
                                             </textFieldCell>
                                         </textField>
                                         <popUpButton verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="mlb-hy-SiN">
-                                            <rect key="frame" x="395" y="373" width="156" height="26"/>
+                                            <rect key="frame" x="70" y="294" width="156" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="During disk activity" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" refusesFirstResponder="YES" state="on" borderStyle="borderAndBezel" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" autoenablesItems="NO" selectedItem="j7d-Ss-CIa" id="wju-3N-8cG">
                                                 <behavior key="behavior" lightByBackground="YES" lightByGray="YES"/>
@@ -1472,7 +1533,7 @@ DQ
                                                 <action selector="perDriveTypeAction:" target="-2" id="L5M-5b-LnE"/>
                                             </connections>
                                         </popUpButton>
-                                        <popUpButton verticalHuggingPriority="750" fixedFrame="YES" tag="1" translatesAutoresizingMaskIntoConstraints="NO" id="TI9-qi-cME">
+                                        <popUpButton tag="1" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="TI9-qi-cME">
                                             <rect key="frame" x="114" y="325" width="162" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="3.5&quot; DD" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="CMh-vG-3cz" id="aSu-Ar-nTk">
@@ -1496,7 +1557,7 @@ DQ
                                                 <action selector="perDriveTypeAction:" target="-2" id="UUg-YV-atk"/>
                                             </connections>
                                         </popUpButton>
-                                        <button fixedFrame="YES" tag="1" translatesAutoresizingMaskIntoConstraints="NO" id="tD2-QB-Kdc">
+                                        <button tag="1" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="tD2-QB-Kdc">
                                             <rect key="frame" x="58" y="330" width="49" height="18"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="check" title="DF1:" bezelStyle="regularSquare" imagePosition="left" alignment="left" state="on" inset="2" id="cQH-Uk-hNH">
@@ -1533,7 +1594,7 @@ DQ
                                                 <action selector="perHdrConnectAction:" target="-2" id="tlz-k2-8TN"/>
                                             </connections>
                                         </button>
-                                        <popUpButton verticalHuggingPriority="750" fixedFrame="YES" tag="1" translatesAutoresizingMaskIntoConstraints="NO" id="l00-2q-mSl">
+                                        <popUpButton tag="1" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="l00-2q-mSl">
                                             <rect key="frame" x="114" y="173" width="162" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="Zorro board" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="spG-S1-nLS" id="9XM-JK-C2q">
@@ -1548,7 +1609,7 @@ DQ
                                                 </menu>
                                             </popUpButtonCell>
                                         </popUpButton>
-                                        <button fixedFrame="YES" tag="1" translatesAutoresizingMaskIntoConstraints="NO" id="Mej-Fl-HiP">
+                                        <button tag="1" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="Mej-Fl-HiP">
                                             <rect key="frame" x="58" y="178" width="55" height="18"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="check" title="HD1:" bezelStyle="regularSquare" imagePosition="left" alignment="left" state="on" inset="2" id="ZyW-KJ-JJl">
@@ -1559,7 +1620,7 @@ DQ
                                                 <action selector="perHdrConnectAction:" target="-2" id="TVh-dg-7ix"/>
                                             </connections>
                                         </button>
-                                        <popUpButton verticalHuggingPriority="750" fixedFrame="YES" tag="2" translatesAutoresizingMaskIntoConstraints="NO" id="kyk-3L-mrA">
+                                        <popUpButton tag="2" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="kyk-3L-mrA">
                                             <rect key="frame" x="114" y="145" width="162" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="Zorro board" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="gp4-6Z-pek" id="R0Q-bF-OE3">
@@ -1574,7 +1635,7 @@ DQ
                                                 </menu>
                                             </popUpButtonCell>
                                         </popUpButton>
-                                        <button fixedFrame="YES" tag="2" translatesAutoresizingMaskIntoConstraints="NO" id="3fY-Lr-qE1">
+                                        <button tag="2" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="3fY-Lr-qE1">
                                             <rect key="frame" x="58" y="150" width="57" height="18"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="check" title="HD2:" bezelStyle="regularSquare" imagePosition="left" alignment="left" state="on" inset="2" id="TMw-MW-0cl">
@@ -1585,7 +1646,7 @@ DQ
                                                 <action selector="perHdrConnectAction:" target="-2" id="8Yb-0K-Shc"/>
                                             </connections>
                                         </button>
-                                        <popUpButton verticalHuggingPriority="750" fixedFrame="YES" tag="3" translatesAutoresizingMaskIntoConstraints="NO" id="wqb-7F-ILE">
+                                        <popUpButton tag="3" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="wqb-7F-ILE">
                                             <rect key="frame" x="114" y="116" width="162" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="Zorro board" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="M8p-fi-xc8" id="a6z-bk-NGQ">
@@ -1600,7 +1661,7 @@ DQ
                                                 </menu>
                                             </popUpButtonCell>
                                         </popUpButton>
-                                        <button fixedFrame="YES" tag="3" translatesAutoresizingMaskIntoConstraints="NO" id="BJQ-gQ-ZtN">
+                                        <button tag="3" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="BJQ-gQ-ZtN">
                                             <rect key="frame" x="58" y="121" width="57" height="18"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="check" title="HD3:" bezelStyle="regularSquare" imagePosition="left" alignment="left" state="on" inset="2" id="AgR-DI-GRJ">
@@ -1611,7 +1672,7 @@ DQ
                                                 <action selector="perHdrConnectAction:" target="-2" id="U7s-Nw-yx2"/>
                                             </connections>
                                         </button>
-                                        <popUpButton verticalHuggingPriority="750" fixedFrame="YES" tag="2" translatesAutoresizingMaskIntoConstraints="NO" id="V0u-IE-VRg">
+                                        <popUpButton tag="2" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="V0u-IE-VRg">
                                             <rect key="frame" x="114" y="295" width="162" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="3.5&quot; DD" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="yVH-t2-BX9" id="cTU-9a-xU9">
@@ -1635,7 +1696,7 @@ DQ
                                                 <action selector="perDriveTypeAction:" target="-2" id="1YK-9q-f7Q"/>
                                             </connections>
                                         </popUpButton>
-                                        <button fixedFrame="YES" tag="2" translatesAutoresizingMaskIntoConstraints="NO" id="n4C-Su-UQM">
+                                        <button tag="2" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="n4C-Su-UQM">
                                             <rect key="frame" x="56" y="300" width="51" height="18"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="check" title="DF2:" bezelStyle="regularSquare" imagePosition="left" alignment="left" state="on" inset="2" id="lJN-DR-Wt6">
@@ -1646,7 +1707,7 @@ DQ
                                                 <action selector="perDriveConnectAction:" target="-2" id="OhV-9a-Vf0"/>
                                             </connections>
                                         </button>
-                                        <popUpButton verticalHuggingPriority="750" fixedFrame="YES" tag="3" translatesAutoresizingMaskIntoConstraints="NO" id="S32-51-0lU">
+                                        <popUpButton tag="3" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="S32-51-0lU">
                                             <rect key="frame" x="114" y="265" width="162" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="3.5&quot; DD" bezelStyle="rounded" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="qhQ-Cc-DkS" id="zBN-vm-21y">
@@ -1670,7 +1731,7 @@ DQ
                                                 <action selector="perDriveTypeAction:" target="-2" id="fmJ-cd-NBU"/>
                                             </connections>
                                         </popUpButton>
-                                        <button fixedFrame="YES" tag="3" translatesAutoresizingMaskIntoConstraints="NO" id="5dd-PL-lVh">
+                                        <button tag="3" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="5dd-PL-lVh">
                                             <rect key="frame" x="56" y="270" width="51" height="18"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <buttonCell key="cell" type="check" title="DF3:" bezelStyle="regularSquare" imagePosition="left" alignment="left" state="on" inset="2" id="EF8-Id-xLv">
@@ -1699,7 +1760,7 @@ DQ
                                                 <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
                                             </textFieldCell>
                                         </textField>
-                                        <popUpButton verticalHuggingPriority="750" fixedFrame="YES" tag="1" translatesAutoresizingMaskIntoConstraints="NO" id="O2O-2C-ZMa">
+                                        <popUpButton tag="1" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="O2O-2C-ZMa">
                                             <rect key="frame" x="412" y="355" width="182" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="No device" bezelStyle="rounded" imagePosition="right" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" tag="-1" imageScaling="proportionallyUpOrDown" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="Ofd-Kt-muY" id="Daj-hR-zEw">
@@ -1750,7 +1811,7 @@ DQ
                                                 <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
                                             </textFieldCell>
                                         </textField>
-                                        <popUpButton verticalHuggingPriority="750" fixedFrame="YES" tag="2" translatesAutoresizingMaskIntoConstraints="NO" id="TAX-DK-yR4">
+                                        <popUpButton tag="2" verticalHuggingPriority="750" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="TAX-DK-yR4">
                                             <rect key="frame" x="412" y="325" width="182" height="26"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMinY="YES"/>
                                             <popUpButtonCell key="cell" type="push" title="No device" bezelStyle="rounded" imagePosition="right" alignment="left" lineBreakMode="truncatingTail" state="on" borderStyle="border" tag="-1" imageScaling="proportionallyUpOrDown" inset="2" arrowPosition="arrowAtCenter" preferredEdge="maxY" selectedItem="PNP-ut-z5R" id="XiY-0N-RIF">
diff --git a/Proxy/AmigaProxy.h b/Proxy/AmigaProxy.h
index 78a8eb4e5..ad8a0dc83 100644
--- a/Proxy/AmigaProxy.h
+++ b/Proxy/AmigaProxy.h
@@ -220,6 +220,7 @@
 @property (readonly) BOOL isWarping;
 @property BOOL trackMode;
 @property (readonly) NSInteger cpuLoad;
+@property (readonly) BOOL fpuSupport;
 @property InspectionTarget inspectionTarget;
 - (void) removeInspectionTarget;
 
diff --git a/Proxy/AmigaProxy.mm b/Proxy/AmigaProxy.mm
index e0007800c..537f0caf6 100644
--- a/Proxy/AmigaProxy.mm
+++ b/Proxy/AmigaProxy.mm
@@ -2832,6 +2832,11 @@ - (NSInteger)cpuLoad
     return (NSInteger)(100 * load);
 }
 
+- (BOOL)fpuSupport
+{
+    return [self amiga]->fpuSupport();
+}
+
 - (InspectionTarget)inspectionTarget
 {
     return [self amiga]->getInspectionTarget();
diff --git a/Resources/Assets.xcassets/Binary/diagrom-13.dataset/Contents.json b/Resources/Assets.xcassets/Binary/diagrom-13.dataset/Contents.json
new file mode 100644
index 000000000..558a1f077
--- /dev/null
+++ b/Resources/Assets.xcassets/Binary/diagrom-13.dataset/Contents.json
@@ -0,0 +1,12 @@
+{
+  "data" : [
+    {
+      "filename" : "diagrom-13.bin",
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/Resources/Assets.xcassets/Binary/diagrom-13.dataset/diagrom-13.bin b/Resources/Assets.xcassets/Binary/diagrom-13.dataset/diagrom-13.bin
new file mode 100644
index 000000000..e9aadb1fd
Binary files /dev/null and b/Resources/Assets.xcassets/Binary/diagrom-13.dataset/diagrom-13.bin differ
diff --git a/vAmiga.xcodeproj/project.pbxproj b/vAmiga.xcodeproj/project.pbxproj
index 81628eb56..7708027da 100644
--- a/vAmiga.xcodeproj/project.pbxproj
+++ b/vAmiga.xcodeproj/project.pbxproj
@@ -73,6 +73,8 @@
 		50357BB823912929007E7563 /* RendererSetup.swift in Sources */ = {isa = PBXBuildFile; fileRef = 50357BB723912929007E7563 /* RendererSetup.swift */; };
 		50384C8621FC6B66006E7748 /* Snapshot.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 50384C8421FC6B66006E7748 /* Snapshot.cpp */; };
 		5039924325B2164E0084B808 /* MyDocumentController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5039924225B2164E0084B808 /* MyDocumentController.swift */; };
+		504098E02A84BE920062DD67 /* FpuFormats.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 504098DE2A84BE920062DD67 /* FpuFormats.cpp */; };
+		504098E12A84BE920062DD67 /* FpuFormats.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 504098DE2A84BE920062DD67 /* FpuFormats.cpp */; };
 		5041C6282791AF0800D3C494 /* SequencerRegs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5041C6272791AF0800D3C494 /* SequencerRegs.cpp */; };
 		5042F2DD26BE57E600126C05 /* Thread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5042F2DB26BE57E600126C05 /* Thread.cpp */; };
 		5043F6C5221972F90047CC30 /* MyToolbar.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5043F6C4221972F90047CC30 /* MyToolbar.swift */; };
@@ -247,6 +249,8 @@
 		50D7CDC42286E968002689F0 /* Joystick.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 50D7CDC22286E968002689F0 /* Joystick.cpp */; };
 		50DD1EE22525E3E1000180F6 /* Preferences.xib in Resources */ = {isa = PBXBuildFile; fileRef = 50DD1EE12525E3E1000180F6 /* Preferences.xib */; };
 		50DD33CC2756113300AE18B4 /* pfile.c in Sources */ = {isa = PBXBuildFile; fileRef = 50DD33CB27560EE600AE18B4 /* pfile.c */; };
+		50DD3AF72A6A8590008FC7CC /* MoiraFPU.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 50DD3AF52A6A8495008FC7CC /* MoiraFPU.cpp */; };
+		50DD3AF82A6A8590008FC7CC /* MoiraFPU.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 50DD3AF52A6A8495008FC7CC /* MoiraFPU.cpp */; };
 		50DED6AF2202EBA200B8195F /* Inspector.xib in Resources */ = {isa = PBXBuildFile; fileRef = 50DED6AE2202EBA200B8195F /* Inspector.xib */; };
 		50DED6B12202EC3100B8195F /* Inspector.swift in Sources */ = {isa = PBXBuildFile; fileRef = 50DED6B02202EC3100B8195F /* Inspector.swift */; };
 		50DF2CA02269135800795256 /* SpriteTableView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 50DF2C9F2269135800795256 /* SpriteTableView.swift */; };
@@ -553,6 +557,8 @@
 		503990C522D8CCB600035783 /* Beam.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Beam.h; sourceTree = "<group>"; };
 		5039924225B2164E0084B808 /* MyDocumentController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MyDocumentController.swift; sourceTree = "<group>"; };
 		5039924625B219FC0084B808 /* Error.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Error.h; sourceTree = "<group>"; };
+		504098DE2A84BE920062DD67 /* FpuFormats.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = FpuFormats.cpp; sourceTree = "<group>"; };
+		504098DF2A84BE920062DD67 /* FpuFormats.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FpuFormats.h; sourceTree = "<group>"; };
 		5041C6272791AF0800D3C494 /* SequencerRegs.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SequencerRegs.cpp; sourceTree = "<group>"; };
 		5042F2DB26BE57E600126C05 /* Thread.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Thread.cpp; sourceTree = "<group>"; };
 		5042F2DC26BE57E600126C05 /* Thread.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Thread.h; sourceTree = "<group>"; };
@@ -862,6 +868,8 @@
 		50D7CDC32286E968002689F0 /* Joystick.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Joystick.h; sourceTree = "<group>"; };
 		50DD1EE12525E3E1000180F6 /* Preferences.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = Preferences.xib; sourceTree = "<group>"; };
 		50DD33CB27560EE600AE18B4 /* pfile.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = pfile.c; sourceTree = "<group>"; };
+		50DD3AF52A6A8495008FC7CC /* MoiraFPU.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = MoiraFPU.cpp; sourceTree = "<group>"; };
+		50DD3AF62A6A8496008FC7CC /* MoiraFPU.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MoiraFPU.h; sourceTree = "<group>"; };
 		50DED6AE2202EBA200B8195F /* Inspector.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = Inspector.xib; sourceTree = "<group>"; };
 		50DED6B02202EC3100B8195F /* Inspector.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Inspector.swift; sourceTree = "<group>"; };
 		50DF2C9E2268CFC000795256 /* AgnusTypes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AgnusTypes.h; sourceTree = "<group>"; };
@@ -1856,10 +1864,14 @@
 				50A6F50328C7AB51002F31EA /* MoiraDasmMMU_cpp.h */,
 				50E2BE26240D418500155AE4 /* MoiraDasm_cpp.h */,
 				50A6F50428C7AB6A002F31EA /* MoiraDasmFPU_cpp.h */,
+				50DD3AF62A6A8496008FC7CC /* MoiraFPU.h */,
+				50DD3AF52A6A8495008FC7CC /* MoiraFPU.cpp */,
 				50E2BE2B240D418500155AE4 /* MoiraDebugger.h */,
 				50E2BE29240D418500155AE4 /* MoiraDebugger.cpp */,
 				50E2BE32240D418600155AE4 /* StrWriter.h */,
 				50E2BE2D240D418500155AE4 /* StrWriter_cpp.h */,
+				504098DF2A84BE920062DD67 /* FpuFormats.h */,
+				504098DE2A84BE920062DD67 /* FpuFormats.cpp */,
 				5002348F28CC8D9500145D6E /* softfloat */,
 			);
 			path = Moira;
@@ -2018,8 +2030,9 @@
 		508FDE5C21EA1FA40043D0E9 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
+				BuildIndependentTargetsInParallel = YES;
 				LastSwiftUpdateCheck = 1010;
-				LastUpgradeCheck = 1400;
+				LastUpgradeCheck = 1430;
 				ORGANIZATIONNAME = "Dirk Hoffmann";
 				TargetAttributes = {
 					508FDE6321EA1FA40043D0E9 = {
@@ -2163,6 +2176,7 @@
 				509C3663260B1D95004F160A /* InterpreterCmds.cpp in Sources */,
 				50AE6EDF24D93EDD000AA367 /* AgnusRegs.cpp in Sources */,
 				50AEBEE024D3D9080037082D /* KeyboardEvents.cpp in Sources */,
+				50DD3AF72A6A8590008FC7CC /* MoiraFPU.cpp in Sources */,
 				50FC08B127819E4100F0C567 /* BlitterInfo.cpp in Sources */,
 				5020B17D21EF121E00B9E80E /* Agnus.cpp in Sources */,
 				50FAC7702515EBED00E47421 /* IMGFile.cpp in Sources */,
@@ -2283,6 +2297,7 @@
 				507957AC244AD25B007B8B8D /* Configuration.swift in Sources */,
 				50F54B3024B5D31D0078FDC9 /* u_quick.c in Sources */,
 				50DD33CC2756113300AE18B4 /* pfile.c in Sources */,
+				504098E02A84BE920062DD67 /* FpuFormats.cpp in Sources */,
 				50950ED822881B7A0073F755 /* ZorroManager.cpp in Sources */,
 				50B70CAD252CE0BF006B5191 /* Muxer.cpp in Sources */,
 				501D686028085131000BB5E9 /* Defaults.cpp in Sources */,
@@ -2419,6 +2434,7 @@
 				50FC04BC27DA19B200C3E566 /* DriveDescriptors.cpp in Sources */,
 				50FC049627DA196C00C3E566 /* DeniseDebugger.cpp in Sources */,
 				50FC04E727DA1A1400C3E566 /* u_deep.c in Sources */,
+				504098E12A84BE920062DD67 /* FpuFormats.cpp in Sources */,
 				50FC04C527DA19DE00C3E566 /* RomFile.cpp in Sources */,
 				50FC04EA27DA1A3900C3E566 /* OSDebuggerDump.cpp in Sources */,
 				50FC048C27DA195600C3E566 /* CIA.cpp in Sources */,
@@ -2488,6 +2504,7 @@
 				50FC04F327DA1A8F00C3E566 /* AudioFilter.cpp in Sources */,
 				50FC04E627DA1A1400C3E566 /* pfile.c in Sources */,
 				50FC04AF27DA199200C3E566 /* DmaDebugger.cpp in Sources */,
+				50DD3AF82A6A8590008FC7CC /* MoiraFPU.cpp in Sources */,
 				50FC04ED27DA1A4500C3E566 /* Socket.cpp in Sources */,
 				50FC048827DA194200C3E566 /* Moira.cpp in Sources */,
 				50EF2236281595AA00440C4D /* Defaults.cpp in Sources */,
@@ -2728,11 +2745,12 @@
 				CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES;
 				CODE_SIGN_ENTITLEMENTS = Resources/vAmiga.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
-				CODE_SIGN_STYLE = Automatic;
+				"CODE_SIGN_IDENTITY[sdk=macosx*]" = "-";
+				CODE_SIGN_STYLE = Manual;
 				COMBINE_HIDPI_IMAGES = YES;
 				CURRENT_PROJECT_VERSION = 230425;
 				DEAD_CODE_STRIPPING = YES;
-				DEVELOPMENT_TEAM = 3NG65ZLYW7;
+				DEVELOPMENT_TEAM = "";
 				ENABLE_APP_SANDBOX = NO;
 				ENABLE_HARDENED_RUNTIME = YES;
 				GCC_ENABLE_BUILTIN_FUNCTIONS = YES;
@@ -2753,6 +2771,7 @@
 				MARKETING_VERSION = 2.4;
 				PRODUCT_BUNDLE_IDENTIFIER = dirkwhoffmann.vAmiga;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_OBJC_BRIDGING_HEADER = "Proxy/Bridging-Header.h";
 				SWIFT_VERSION = 5.0;
 				WARNING_CFLAGS = (
@@ -2773,11 +2792,12 @@
 				CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES;
 				CODE_SIGN_ENTITLEMENTS = Resources/vAmiga.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
-				CODE_SIGN_STYLE = Automatic;
+				"CODE_SIGN_IDENTITY[sdk=macosx*]" = "-";
+				CODE_SIGN_STYLE = Manual;
 				COMBINE_HIDPI_IMAGES = YES;
 				CURRENT_PROJECT_VERSION = 230425;
 				DEAD_CODE_STRIPPING = YES;
-				DEVELOPMENT_TEAM = 3NG65ZLYW7;
+				DEVELOPMENT_TEAM = "";
 				ENABLE_APP_SANDBOX = NO;
 				ENABLE_HARDENED_RUNTIME = YES;
 				GCC_ENABLE_BUILTIN_FUNCTIONS = YES;
@@ -2796,6 +2816,7 @@
 				MARKETING_VERSION = 2.4;
 				PRODUCT_BUNDLE_IDENTIFIER = dirkwhoffmann.vAmiga;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_OBJC_BRIDGING_HEADER = "Proxy/Bridging-Header.h";
 				SWIFT_VERSION = 5.0;
 				WARNING_CFLAGS = (
diff --git a/vAmiga.xcodeproj/xcshareddata/xcschemes/vAmiga.xcscheme b/vAmiga.xcodeproj/xcshareddata/xcschemes/vAmiga.xcscheme
index 92abdf405..d2ac24725 100644
--- a/vAmiga.xcodeproj/xcshareddata/xcschemes/vAmiga.xcscheme
+++ b/vAmiga.xcodeproj/xcshareddata/xcschemes/vAmiga.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "1400"
+   LastUpgradeVersion = "1430"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
diff --git a/vAmiga.xcodeproj/xcshareddata/xcschemes/vAmigaCore.xcscheme b/vAmiga.xcodeproj/xcshareddata/xcschemes/vAmigaCore.xcscheme
index 542cc50a8..1d3356c39 100644
--- a/vAmiga.xcodeproj/xcshareddata/xcschemes/vAmigaCore.xcscheme
+++ b/vAmiga.xcodeproj/xcshareddata/xcschemes/vAmigaCore.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "1400"
+   LastUpgradeVersion = "1430"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
diff --git a/vAmiga.xcodeproj/xcuserdata/hoff.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/vAmiga.xcodeproj/xcuserdata/hoff.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
index 024867fce..df16a3893 100644
--- a/vAmiga.xcodeproj/xcuserdata/hoff.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
+++ b/vAmiga.xcodeproj/xcuserdata/hoff.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
@@ -159,5 +159,219 @@
             landmarkType = "3">
          </BreakpointContent>
       </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "D70351F2-6ECF-4625-9656-1E5482F44C8D"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "Emulator/Components/CPU/Moira/MoiraFPU.cpp"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "508"
+            endingLineNumber = "508"
+            landmarkName = "FPU::resolveNan(op1, op2)"
+            landmarkType = "7">
+         </BreakpointContent>
+      </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8"
+            shouldBeEnabled = "Yes"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "Emulator/Components/CPU/Moira/Moira.cpp"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "435"
+            endingLineNumber = "435"
+            landmarkName = "Moira::processException(exc)"
+            landmarkType = "7">
+            <Locations>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - bb4eac4959700333"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)0&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "180">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - bb4eac4959700333"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)0&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "508">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - e9f68e6274443b32"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)1&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "180">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - e9f68e6274443b32"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)1&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "508">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - 161ee00767a8d331"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)2&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "180">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - 161ee00767a8d331"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)2&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "508">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - bb4eac4959700333"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)0&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "572">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - e9f68e6274443b32"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)1&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "572">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - 161ee00767a8d331"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)2&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "436"
+                  endingLineNumber = "436"
+                  offsetFromSymbolStart = "572">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - bb4eac495970031c"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)0&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "435"
+                  endingLineNumber = "435"
+                  offsetFromSymbolStart = "536">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - e9f68e6274443b1d"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)1&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "435"
+                  endingLineNumber = "435"
+                  offsetFromSymbolStart = "536">
+               </Location>
+               <Location
+                  uuid = "9F889B32-39C8-498F-AFC3-14E8073A26C8 - 161ee00767a8d31e"
+                  shouldBeEnabled = "Yes"
+                  ignoreCount = "0"
+                  continueAfterRunningActions = "No"
+                  symbolName = "void vamiga::moira::Moira::processException&lt;(vamiga::moira::Core)2&gt;(std::exception const&amp;)"
+                  moduleName = "vAmiga"
+                  usesParentBreakpointCondition = "Yes"
+                  urlString = "file:///Users/hoff/Retro/vAmiga/Emulator/Components/CPU/Moira/Moira.cpp"
+                  startingColumnNumber = "9223372036854775807"
+                  endingColumnNumber = "9223372036854775807"
+                  startingLineNumber = "435"
+                  endingLineNumber = "435"
+                  offsetFromSymbolStart = "536">
+               </Location>
+            </Locations>
+         </BreakpointContent>
+      </BreakpointProxy>
    </Breakpoints>
 </Bucket>