diff --git a/DataSpec/DNACommon/CMakeLists.txt b/DataSpec/DNACommon/CMakeLists.txt
index 731a76125..15f3408ec 100644
--- a/DataSpec/DNACommon/CMakeLists.txt
+++ b/DataSpec/DNACommon/CMakeLists.txt
@@ -42,7 +42,10 @@ set(DNACOMMON_SOURCES
     Tweaks/ITweakPlayerRes.hpp
     Tweaks/ITweakGui.hpp
     Tweaks/ITweakSlideShow.hpp
-    Tweaks/ITweakTargeting.hpp)
+    Tweaks/ITweakTargeting.hpp
+    Tweaks/ITweakAutoMapper.hpp
+    Tweaks/ITweakBall.hpp
+    Tweaks/ITweakGuiColors.hpp)
 
 dataspec_add_list(DNACommon DNACOMMON_SOURCES)
 list(APPEND DNACOMMON_SOURCES ${liblist})
diff --git a/DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp b/DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp
new file mode 100644
index 000000000..7e7e89433
--- /dev/null
+++ b/DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp
@@ -0,0 +1,15 @@
+#ifndef __DNACOMMON_ITWEAKAUTOMAPPER_HPP__
+#define __DNACOMMON_ITWEAKAUTOMAPPER_HPP__
+
+#include "ITweak.hpp"
+
+namespace DataSpec
+{
+struct ITweakAutoMapper : public ITweak
+{
+    virtual const zeus::CVector3f& GetDoorCenter() const=0;
+};
+}
+
+
+#endif // __DNACOMMON_ITWEAKAUTOMAPPER_HPP__
diff --git a/DataSpec/DNACommon/Tweaks/ITweakBall.hpp b/DataSpec/DNACommon/Tweaks/ITweakBall.hpp
new file mode 100644
index 000000000..5a85d0cfc
--- /dev/null
+++ b/DataSpec/DNACommon/Tweaks/ITweakBall.hpp
@@ -0,0 +1,14 @@
+#ifndef __DNACOMMON_ITWEAKBALL_HPP__
+#define __DNACOMMON_ITWEAKBALL_HPP__
+
+#include "ITweak.hpp"
+
+namespace DataSpec
+{
+struct ITweakBall : ITweak
+{
+
+};
+}
+
+#endif // __DNACOMMON_ITWEAKBALL_HPP__
diff --git a/DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp b/DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp
new file mode 100644
index 000000000..c6bd392aa
--- /dev/null
+++ b/DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp
@@ -0,0 +1,13 @@
+#ifndef __DNACOMMON_ITWEAKGUICOLORS_HPP__
+#define __DNACOMMON_ITWEAKGUICOLORS_HPP__
+
+#include "../DNACommon.hpp"
+
+namespace DataSpec
+{
+struct ITweakGuiColors : BigYAML
+{
+};
+}
+
+#endif // __DNACOMMON_ITWEAKGUICOLORS_HPP__
diff --git a/DataSpec/DNAMP1/CMakeLists.txt b/DataSpec/DNAMP1/CMakeLists.txt
index 631e93233..98438d243 100644
--- a/DataSpec/DNAMP1/CMakeLists.txt
+++ b/DataSpec/DNAMP1/CMakeLists.txt
@@ -29,7 +29,10 @@ make_dnalist(liblist DNAMP1
              Tweaks/CTweakGui
              Tweaks/CTweakSlideShow
              Tweaks/CTweakCameraBob
-             Tweaks/CTweakTargeting)
+             Tweaks/CTweakTargeting
+             Tweaks/CTweakAutoMapper
+             Tweaks/CTweakBall
+             Tweaks/CTweakGuiColors)
 
 set(DNAMP1_SOURCES
     DNAMP1.hpp DNAMP1.cpp
@@ -50,7 +53,8 @@ set(DNAMP1_SOURCES
     FRME.cpp
     DeafBabe.cpp
     Tweaks/CTweakPlayer.cpp
-    Tweaks/CTweakTargeting.cpp)
+    Tweaks/CTweakTargeting.cpp
+    Tweaks/CTweakBall.cpp)
 
 dataspec_add_list(DNAMP1 DNAMP1_SOURCES)
 list(APPEND DNAMP1_SOURCES ${liblist})
diff --git a/DataSpec/DNAMP1/DNAMP1.cpp b/DataSpec/DNAMP1/DNAMP1.cpp
index 594fdd5d2..20a6299b3 100644
--- a/DataSpec/DNAMP1/DNAMP1.cpp
+++ b/DataSpec/DNAMP1/DNAMP1.cpp
@@ -34,7 +34,12 @@
 #include "Tweaks/CTweakSlideShow.hpp"
 #include "Tweaks/CTweakGame.hpp"
 #include "Tweaks/CTweakTargeting.hpp"
+#include "Tweaks/CTweakAutoMapper.hpp"
 #include "Tweaks/CTweakGui.hpp"
+#include "Tweaks/CTweakPlayerControl.hpp"
+#include "Tweaks/CTweakBall.hpp"
+#include "Tweaks/CTweakParticle.hpp"
+#include "Tweaks/CTweakGuiColors.hpp"
 
 namespace DataSpec
 {
@@ -391,6 +396,16 @@ ResExtractor<PAKBridge> PAKBridge::LookupExtractor(const PAK& pak, const PAK::En
                 return {ExtractTweak<CTweakTargeting>, {_S(".yaml")}};
             if (!name.compare("Gui"))
                 return {ExtractTweak<CTweakGui>, {_S(".yaml")}};
+            if (!name.compare("AutoMapper"))
+                return {ExtractTweak<CTweakAutoMapper>, {_S(".yaml")}};
+            if (!name.compare("PlayerControls") || !name.compare("PlayerControls2"))
+                return {ExtractTweak<CTweakPlayerControl>, {_S(".yaml")}};
+            if (!name.compare("Ball"))
+                return {ExtractTweak<CTweakBall>, {_S(".yaml")}};
+            if (!name.compare("Particle"))
+                return {ExtractTweak<CTweakParticle>, {_S(".yaml")}};
+            if (!name.compare("GuiColors"))
+                return {ExtractTweak<CTweakGuiColors>, {_S(".yaml")}};
         }
         break;
     }
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.cpp b/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.cpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp b/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp
new file mode 100644
index 000000000..23b7bc72d
--- /dev/null
+++ b/DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp
@@ -0,0 +1,90 @@
+#ifndef __DNAMP1_CTWEAKAUTOMAPPER_HPP__
+#define __DNAMP1_CTWEAKAUTOMAPPER_HPP__
+
+#include "../../DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp"
+#include "zeus/CVector3f.hpp"
+
+namespace DataSpec
+{
+namespace DNAMP1
+{
+struct CTweakAutoMapper : public ITweakAutoMapper
+{
+    DECL_YAML
+    Value<bool> x4_24_ : 1;
+    Value<bool> x4_25_ : 1;
+    Value<bool> x4_26_ : 1;
+    Value<float> x8_;
+    Value<float> xc_;
+    Value<float> x10_;
+    Value<float> x14_;
+    Value<float> x18_;
+    Value<float> x1c_;
+    Value<float> x20_;
+    DNAColor x24_;
+    Value<float> x28_;
+    Value<float> x2c_;
+    Value<float> x30_;
+    Value<float> x34_;
+    DNAColor x38_;
+    DNAColor x3c_;
+    DNAColor x40_;
+    DNAColor x44_;
+    DNAColor x48_;
+    DNAColor x4c_;
+    DNAColor x50_;
+    Value<float> x54_;
+    Value<float> x58_;
+    Value<float> x5c_;
+    float x60_ = 0.4f;
+    Value<float> x64_;
+    Value<float> x68_;
+    Value<float> x6c_;
+    Value<float> x70_;
+    Value<float> x74_;
+    Value<float> x78_;
+    DNAColor x7c_;
+    DNAColor x80_;
+    Value<float> x84_;
+    Value<float> x88_;
+    Value<float> x8c_;
+    Value<float> x90_;
+    Value<float> x94_;
+    Value<float> x98_;
+    Value<float> x9c_;
+    Value<float> xa0_;
+    /* Originally 4 separate floats */
+    Value<zeus::CVector3f> xa4_doorCenter;
+    Value<float> xb0_;
+    Value<float> xb4_;
+    Value<float> xb8_;
+    Value<float> xbc_;
+    Value<float> xc0_;
+    Value<float> xc4_;
+    Value<float> xc8_;
+    Value<bool> xcc_;
+    Value<float> xd0_;
+    Value<float> xd4_;
+    Value<float> xd8_;
+    Value<float> xdc_;
+    Value<float> xe0_;
+    Value<float> xe4_;
+    Value<float> xe8_;
+    Value<float> xec_;
+    DNAColor xf0_;
+    DNAColor xf4_;
+    DNAColor xf8_;
+    DNAColor xfc_;
+    Value<atUint32> x100_doorColorCount;
+    Vector<DNAColor, DNA_COUNT(x100_doorColorCount)> x104_doorColors;
+    DNAColor x118_doorBorderColor;
+    DNAColor x11c_openDoorColor;
+
+    CTweakAutoMapper() = default;
+    CTweakAutoMapper(athena::io::IStreamReader& r) { this->read(r); }
+    const zeus::CVector3f& GetDoorCenter() const { return xa4_doorCenter; }
+};
+}
+}
+
+#endif // __DNAMP1_CTWEAKAUTOMAPPER_HPP__
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakBall.cpp b/DataSpec/DNAMP1/Tweaks/CTweakBall.cpp
new file mode 100644
index 000000000..83134b9a3
--- /dev/null
+++ b/DataSpec/DNAMP1/Tweaks/CTweakBall.cpp
@@ -0,0 +1,935 @@
+#include "CTweakBall.hpp"
+
+namespace DataSpec
+{
+namespace DNAMP1
+{
+
+void CTweakBall::read(athena::io::IStreamReader& __dna_reader)
+{
+    /* x4_[0] */
+    x4_[0] = __dna_reader.readFloatBig();
+    /* x4_[1] */
+    x4_[1] = __dna_reader.readFloatBig();
+    /* x4_[2] */
+    x4_[2] = __dna_reader.readFloatBig();
+    /* x4_[3] */
+    x4_[3] = __dna_reader.readFloatBig();
+    /* x4_[4] */
+    x4_[4] = __dna_reader.readFloatBig();
+    /* x4_[5] */
+    x4_[5] = __dna_reader.readFloatBig();
+    /* x4_[6] */
+    x4_[6] = __dna_reader.readFloatBig();
+    /* x4_[7] */
+    x4_[7] = __dna_reader.readFloatBig();
+    /* x24_[0] */
+    x24_[0] = __dna_reader.readFloatBig();
+    /* x24_[1] */
+    x24_[1] = __dna_reader.readFloatBig();
+    /* x24_[2] */
+    x24_[2] = __dna_reader.readFloatBig();
+    /* x24_[3] */
+    x24_[3] = __dna_reader.readFloatBig();
+    /* x24_[4] */
+    x24_[4] = __dna_reader.readFloatBig();
+    /* x24_[5] */
+    x24_[5] = __dna_reader.readFloatBig();
+    /* x24_[6] */
+    x24_[6] = __dna_reader.readFloatBig();
+    /* x24_[7] */
+    x24_[7] = __dna_reader.readFloatBig();
+    /* x44_[0] */
+    x44_[0] = __dna_reader.readFloatBig();
+    /* x44_[1] */
+    x44_[1] = __dna_reader.readFloatBig();
+    /* x44_[2] */
+    x44_[2] = __dna_reader.readFloatBig();
+    /* x44_[3] */
+    x44_[3] = __dna_reader.readFloatBig();
+    /* x44_[4] */
+    x44_[4] = __dna_reader.readFloatBig();
+    /* x44_[5] */
+    x44_[5] = __dna_reader.readFloatBig();
+    /* x44_[6] */
+    x44_[6] = __dna_reader.readFloatBig();
+    /* x44_[7] */
+    x44_[7] = __dna_reader.readFloatBig();
+    /* x64_ */
+    x64_ = __dna_reader.readFloatBig();
+    /* x68_ */
+    x68_ = __dna_reader.readFloatBig();
+    /* x6c_ */
+    x6c_ = __dna_reader.readFloatBig();
+    /* x70_ */
+    x70_ = __dna_reader.readFloatBig();
+    /* xc4_[0] */
+    xc4_[0] = __dna_reader.readFloatBig();
+    /* xc4_[1] */
+    xc4_[1] = __dna_reader.readFloatBig();
+    /* xc4_[2] */
+    xc4_[2] = __dna_reader.readFloatBig();
+    /* xc4_[3] */
+    xc4_[3] = __dna_reader.readFloatBig();
+    /* xc4_[4] */
+    xc4_[4] = __dna_reader.readFloatBig();
+    /* xc4_[5] */
+    xc4_[5] = __dna_reader.readFloatBig();
+    /* xc4_[6] */
+    xc4_[6] = __dna_reader.readFloatBig();
+    /* xc4_[7] */
+    xc4_[7] = __dna_reader.readFloatBig();
+    /* xe4_ */
+    xe4_ = __dna_reader.readFloatBig();
+    /* xe8_ */
+    xe8_ = __dna_reader.readFloatBig();
+    /* x14c_ */
+    x14c_ = __dna_reader.readFloatBig();
+    /* x150_ */
+    x150_ = __dna_reader.readFloatBig();
+    /* x158_ */
+    x158_ = __dna_reader.readFloatBig();
+    /* x1dc_ */
+    x1dc_ = __dna_reader.readFloatBig();
+    /* x1e0_ */
+    x1e0_ = __dna_reader.readFloatBig();
+    /* x1ec_ */
+    x1ec_ = __dna_reader.readFloatBig();
+    /* x1f0_ */
+    x1f0_ = __dna_reader.readFloatBig();
+    /* x1f4_ */
+    x1f4_ = __dna_reader.readFloatBig();
+    /* x1f8_ */
+    x1f8_ = __dna_reader.readFloatBig();
+    /* x1fc_ */
+    x1fc_ = __dna_reader.readFloatBig();
+    /* x74_ */
+    x74_ = __dna_reader.readFloatBig();
+    /* x78_ */
+    x78_ = __dna_reader.readVec3fBig();
+    /* x84_ */
+    x84_ = __dna_reader.readFloatBig();
+    /* x88_ */
+    x88_ = __dna_reader.readFloatBig();
+    /* x8c_ */
+    x8c_ = __dna_reader.readFloatBig();
+    /* x90_ */
+    x90_ = __dna_reader.readFloatBig();
+    /* x94_ */
+    x94_ = __dna_reader.readFloatBig();
+    /* x98_ */
+    x98_ = __dna_reader.readFloatBig();
+    /* x9c_ */
+    x9c_ = __dna_reader.readFloatBig();
+    /* xa0_ */
+    xa0_ = __dna_reader.readFloatBig();
+    /* xa4_ */
+    xa4_ = __dna_reader.readFloatBig();
+    /* xa8_ */
+    xa8_ = __dna_reader.readFloatBig();
+    /* xac_ */
+    xac_ = __dna_reader.readFloatBig();
+    /* xb0_ */
+    xb0_ = __dna_reader.readFloatBig();
+    /* xb4_ */
+    xb4_ = __dna_reader.readFloatBig();
+    /* xb8_ */
+    xb8_ = __dna_reader.readFloatBig();
+    /* xbc_ */
+    xbc_ = __dna_reader.readFloatBig();
+    /* xc0_ */
+    xc0_ = __dna_reader.readFloatBig();
+    /* x154_ */
+    x154_ = __dna_reader.readFloatBig();
+    /* x15c_ */
+    x15c_ = __dna_reader.readFloatBig();
+    /* x160_ */
+    x160_ = __dna_reader.readFloatBig();
+    /* x164_ */
+    x164_ = __dna_reader.readFloatBig();
+    /* x168_ */
+    x168_ = __dna_reader.readFloatBig();
+    /* x16c_ */
+    x16c_ = __dna_reader.readFloatBig();
+    /* x170_ */
+    x170_ = __dna_reader.readFloatBig();
+    /* x174_ */
+    x174_ = __dna_reader.readFloatBig();
+    /* x178_ */
+    x178_ = __dna_reader.readFloatBig();
+    /* x17c_ */
+    x17c_ = __dna_reader.readFloatBig();
+    /* x180_ */
+    x180_ = __dna_reader.readFloatBig();
+    /* x184_ */
+    x184_ = __dna_reader.readFloatBig();
+    /* x188_ */
+    x188_ = __dna_reader.readFloatBig();
+    /* x18c_ */
+    x18c_ = __dna_reader.readVec3fBig();
+    /* x198_ */
+    x198_ = __dna_reader.readFloatBig();
+    /* x19c_ */
+    x19c_ = __dna_reader.readFloatBig();
+    /* x1a0_ */
+    x1a0_ = __dna_reader.readFloatBig();
+    /* x1a4_ */
+    x1a4_ = __dna_reader.readFloatBig();
+    /* x1a8_ */
+    x1a8_ = __dna_reader.readFloatBig();
+    /* x1ac_ */
+    x1ac_ = __dna_reader.readFloatBig();
+    /* x1b0_ */
+    x1b0_ = __dna_reader.readFloatBig();
+    /* x1b4_ */
+    x1b4_ = __dna_reader.readFloatBig();
+    /* x1b8_ */
+    x1b8_ = __dna_reader.readVec3fBig();
+    /* x1c4_ */
+    x1c4_ = __dna_reader.readFloatBig();
+    /* x1c8_ */
+    x1c8_ = __dna_reader.readFloatBig();
+    /* x1cc_ */
+    x1cc_ = __dna_reader.readFloatBig();
+    /* x1d0_ */
+    x1d0_ = __dna_reader.readFloatBig();
+    /* x1d4_ */
+    x1d4_ = __dna_reader.readFloatBig();
+    /* x1d8_ */
+    x1d8_ = __dna_reader.readFloatBig();
+    /* x1e4_ */
+    x1e4_ = __dna_reader.readFloatBig();
+    /* x1e8_ */
+    x1e8_ = __dna_reader.readFloatBig();
+    /* x200_ */
+    x200_ = __dna_reader.readFloatBig();
+    /* x204_ */
+    x204_ = __dna_reader.readFloatBig();
+    /* x20c_ */
+    x20c_ = __dna_reader.readFloatBig();
+    /* x218_ */
+    x218_ = __dna_reader.readFloatBig();
+    /* x21c_ */
+    x21c_ = __dna_reader.readFloatBig();
+    /* x220_ */
+    x220_ = __dna_reader.readFloatBig();
+    /* x224_ */
+    x224_ = __dna_reader.readFloatBig();
+    /* x210_ */
+    x210_ = __dna_reader.readFloatBig();
+    /* x22c_ */
+    x22c_ = __dna_reader.readFloatBig();
+    /* x230_ */
+    x230_ = __dna_reader.readFloatBig();
+    /* x234_ */
+    x234_ = __dna_reader.readFloatBig();
+}
+
+void CTweakBall::write(athena::io::IStreamWriter& __dna_writer) const
+{
+    /* x4_[0] */
+    __dna_writer.writeFloatBig(x4_[0]);
+    /* x4_[1] */
+    __dna_writer.writeFloatBig(x4_[1]);
+    /* x4_[2] */
+    __dna_writer.writeFloatBig(x4_[2]);
+    /* x4_[3] */
+    __dna_writer.writeFloatBig(x4_[3]);
+    /* x4_[4] */
+    __dna_writer.writeFloatBig(x4_[4]);
+    /* x4_[5] */
+    __dna_writer.writeFloatBig(x4_[5]);
+    /* x4_[6] */
+    __dna_writer.writeFloatBig(x4_[6]);
+    /* x4_[7] */
+    __dna_writer.writeFloatBig(x4_[7]);
+    /* x24_[0] */
+    __dna_writer.writeFloatBig(x24_[0]);
+    /* x24_[1] */
+    __dna_writer.writeFloatBig(x24_[1]);
+    /* x24_[2] */
+    __dna_writer.writeFloatBig(x24_[2]);
+    /* x24_[3] */
+    __dna_writer.writeFloatBig(x24_[3]);
+    /* x24_[4] */
+    __dna_writer.writeFloatBig(x24_[4]);
+    /* x24_[5] */
+    __dna_writer.writeFloatBig(x24_[5]);
+    /* x24_[6] */
+    __dna_writer.writeFloatBig(x24_[6]);
+    /* x24_[7] */
+    __dna_writer.writeFloatBig(x24_[7]);
+    /* x44_[0] */
+    __dna_writer.writeFloatBig(x44_[0]);
+    /* x44_[1] */
+    __dna_writer.writeFloatBig(x44_[1]);
+    /* x44_[2] */
+    __dna_writer.writeFloatBig(x44_[2]);
+    /* x44_[3] */
+    __dna_writer.writeFloatBig(x44_[3]);
+    /* x44_[4] */
+    __dna_writer.writeFloatBig(x44_[4]);
+    /* x44_[5] */
+    __dna_writer.writeFloatBig(x44_[5]);
+    /* x44_[6] */
+    __dna_writer.writeFloatBig(x44_[6]);
+    /* x44_[7] */
+    __dna_writer.writeFloatBig(x44_[7]);
+    /* x64_ */
+    __dna_writer.writeFloatBig(x64_);
+    /* x68_ */
+    __dna_writer.writeFloatBig(x68_);
+    /* x6c_ */
+    __dna_writer.writeFloatBig(x6c_);
+    /* x70_ */
+    __dna_writer.writeFloatBig(x70_);
+    /* xc4_[0] */
+    __dna_writer.writeFloatBig(xc4_[0]);
+    /* xc4_[1] */
+    __dna_writer.writeFloatBig(xc4_[1]);
+    /* xc4_[2] */
+    __dna_writer.writeFloatBig(xc4_[2]);
+    /* xc4_[3] */
+    __dna_writer.writeFloatBig(xc4_[3]);
+    /* xc4_[4] */
+    __dna_writer.writeFloatBig(xc4_[4]);
+    /* xc4_[5] */
+    __dna_writer.writeFloatBig(xc4_[5]);
+    /* xc4_[6] */
+    __dna_writer.writeFloatBig(xc4_[6]);
+    /* xc4_[7] */
+    __dna_writer.writeFloatBig(xc4_[7]);
+    /* xe4_ */
+    __dna_writer.writeFloatBig(xe4_);
+    /* xe8_ */
+    __dna_writer.writeFloatBig(xe8_);
+    /* x14c_ */
+    __dna_writer.writeFloatBig(x14c_);
+    /* x150_ */
+    __dna_writer.writeFloatBig(x150_);
+    /* x158_ */
+    __dna_writer.writeFloatBig(x158_);
+    /* x1dc_ */
+    __dna_writer.writeFloatBig(x1dc_);
+    /* x1e0_ */
+    __dna_writer.writeFloatBig(x1e0_);
+    /* x1ec_ */
+    __dna_writer.writeFloatBig(x1ec_);
+    /* x1f0_ */
+    __dna_writer.writeFloatBig(x1f0_);
+    /* x1f4_ */
+    __dna_writer.writeFloatBig(x1f4_);
+    /* x1f8_ */
+    __dna_writer.writeFloatBig(x1f8_);
+    /* x1fc_ */
+    __dna_writer.writeFloatBig(x1fc_);
+    /* x74_ */
+    __dna_writer.writeFloatBig(x74_);
+    /* x78_ */
+    __dna_writer.writeVec3fBig(x78_);
+    /* x84_ */
+    __dna_writer.writeFloatBig(x84_);
+    /* x88_ */
+    __dna_writer.writeFloatBig(x88_);
+    /* x8c_ */
+    __dna_writer.writeFloatBig(x8c_);
+    /* x90_ */
+    __dna_writer.writeFloatBig(x90_);
+    /* x94_ */
+    __dna_writer.writeFloatBig(x94_);
+    /* x98_ */
+    __dna_writer.writeFloatBig(x98_);
+    /* x9c_ */
+    __dna_writer.writeFloatBig(x9c_);
+    /* xa0_ */
+    __dna_writer.writeFloatBig(xa0_);
+    /* xa4_ */
+    __dna_writer.writeFloatBig(xa4_);
+    /* xa8_ */
+    __dna_writer.writeFloatBig(xa8_);
+    /* xac_ */
+    __dna_writer.writeFloatBig(xac_);
+    /* xb0_ */
+    __dna_writer.writeFloatBig(xb0_);
+    /* xb4_ */
+    __dna_writer.writeFloatBig(xb4_);
+    /* xb8_ */
+    __dna_writer.writeFloatBig(xb8_);
+    /* xbc_ */
+    __dna_writer.writeFloatBig(xbc_);
+    /* xc0_ */
+    __dna_writer.writeFloatBig(xc0_);
+    /* x154_ */
+    __dna_writer.writeFloatBig(x154_);
+    /* x15c_ */
+    __dna_writer.writeFloatBig(x15c_);
+    /* x160_ */
+    __dna_writer.writeFloatBig(x160_);
+    /* x164_ */
+    __dna_writer.writeFloatBig(x164_);
+    /* x168_ */
+    __dna_writer.writeFloatBig(x168_);
+    /* x16c_ */
+    __dna_writer.writeFloatBig(x16c_);
+    /* x170_ */
+    __dna_writer.writeFloatBig(x170_);
+    /* x174_ */
+    __dna_writer.writeFloatBig(x174_);
+    /* x178_ */
+    __dna_writer.writeFloatBig(x178_);
+    /* x17c_ */
+    __dna_writer.writeFloatBig(x17c_);
+    /* x180_ */
+    __dna_writer.writeFloatBig(x180_);
+    /* x184_ */
+    __dna_writer.writeFloatBig(x184_);
+    /* x188_ */
+    __dna_writer.writeFloatBig(x188_);
+    /* x18c_ */
+    __dna_writer.writeVec3fBig(x18c_);
+    /* x198_ */
+    __dna_writer.writeFloatBig(x198_);
+    /* x19c_ */
+    __dna_writer.writeFloatBig(x19c_);
+    /* x1a0_ */
+    __dna_writer.writeFloatBig(x1a0_);
+    /* x1a4_ */
+    __dna_writer.writeFloatBig(x1a4_);
+    /* x1a8_ */
+    __dna_writer.writeFloatBig(x1a8_);
+    /* x1ac_ */
+    __dna_writer.writeFloatBig(x1ac_);
+    /* x1b0_ */
+    __dna_writer.writeFloatBig(x1b0_);
+    /* x1b4_ */
+    __dna_writer.writeFloatBig(x1b4_);
+    /* x1b8_ */
+    __dna_writer.writeVec3fBig(x1b8_);
+    /* x1c4_ */
+    __dna_writer.writeFloatBig(x1c4_);
+    /* x1c8_ */
+    __dna_writer.writeFloatBig(x1c8_);
+    /* x1cc_ */
+    __dna_writer.writeFloatBig(x1cc_);
+    /* x1d0_ */
+    __dna_writer.writeFloatBig(x1d0_);
+    /* x1d4_ */
+    __dna_writer.writeFloatBig(x1d4_);
+    /* x1d8_ */
+    __dna_writer.writeFloatBig(x1d8_);
+    /* x1e4_ */
+    __dna_writer.writeFloatBig(x1e4_);
+    /* x1e8_ */
+    __dna_writer.writeFloatBig(x1e8_);
+    /* x200_ */
+    __dna_writer.writeFloatBig(x200_);
+    /* x204_ */
+    __dna_writer.writeFloatBig(x204_);
+    /* x20c_ */
+    __dna_writer.writeFloatBig(x20c_);
+    /* x218_ */
+    __dna_writer.writeFloatBig(x218_);
+    /* x21c_ */
+    __dna_writer.writeFloatBig(x21c_);
+    /* x220_ */
+    __dna_writer.writeFloatBig(x220_);
+    /* x224_ */
+    __dna_writer.writeFloatBig(x224_);
+    /* x210_ */
+    __dna_writer.writeFloatBig(x210_);
+    /* x22c_ */
+    __dna_writer.writeFloatBig(x22c_);
+    /* x230_ */
+    __dna_writer.writeFloatBig(x230_);
+    /* x234_ */
+    __dna_writer.writeFloatBig(x234_);
+}
+
+void CTweakBall::read(athena::io::YAMLDocReader& __dna_docin)
+{
+    /* x4_ */
+    size_t __x4_Count;
+    __dna_docin.enterSubVector("x4_", __x4_Count);
+    /* x4_[0] */
+    x4_[0] = __dna_docin.readFloat("x4_");
+    /* x4_[1] */
+    x4_[1] = __dna_docin.readFloat("x4_");
+    /* x4_[2] */
+    x4_[2] = __dna_docin.readFloat("x4_");
+    /* x4_[3] */
+    x4_[3] = __dna_docin.readFloat("x4_");
+    /* x4_[4] */
+    x4_[4] = __dna_docin.readFloat("x4_");
+    /* x4_[5] */
+    x4_[5] = __dna_docin.readFloat("x4_");
+    /* x4_[6] */
+    x4_[6] = __dna_docin.readFloat("x4_");
+    /* x4_[7] */
+    x4_[7] = __dna_docin.readFloat("x4_");
+    /*  */
+    __dna_docin.leaveSubVector();
+    /* x24_ */
+    size_t __x24_Count;
+    __dna_docin.enterSubVector("x24_", __x24_Count);
+    /* x24_[0] */
+    x24_[0] = __dna_docin.readFloat("x24_");
+    /* x24_[1] */
+    x24_[1] = __dna_docin.readFloat("x24_");
+    /* x24_[2] */
+    x24_[2] = __dna_docin.readFloat("x24_");
+    /* x24_[3] */
+    x24_[3] = __dna_docin.readFloat("x24_");
+    /* x24_[4] */
+    x24_[4] = __dna_docin.readFloat("x24_");
+    /* x24_[5] */
+    x24_[5] = __dna_docin.readFloat("x24_");
+    /* x24_[6] */
+    x24_[6] = __dna_docin.readFloat("x24_");
+    /* x24_[7] */
+    x24_[7] = __dna_docin.readFloat("x24_");
+    /*  */
+    __dna_docin.leaveSubVector();
+    /* x44_ */
+    size_t __x44_Count;
+    __dna_docin.enterSubVector("x44_", __x44_Count);
+    /* x44_[0] */
+    x44_[0] = __dna_docin.readFloat("x44_");
+    /* x44_[1] */
+    x44_[1] = __dna_docin.readFloat("x44_");
+    /* x44_[2] */
+    x44_[2] = __dna_docin.readFloat("x44_");
+    /* x44_[3] */
+    x44_[3] = __dna_docin.readFloat("x44_");
+    /* x44_[4] */
+    x44_[4] = __dna_docin.readFloat("x44_");
+    /* x44_[5] */
+    x44_[5] = __dna_docin.readFloat("x44_");
+    /* x44_[6] */
+    x44_[6] = __dna_docin.readFloat("x44_");
+    /* x44_[7] */
+    x44_[7] = __dna_docin.readFloat("x44_");
+    /*  */
+    __dna_docin.leaveSubVector();
+    /* x64_ */
+    x64_ = __dna_docin.readFloat("x64_");
+    /* x68_ */
+    x68_ = __dna_docin.readFloat("x68_");
+    /* x6c_ */
+    x6c_ = __dna_docin.readFloat("x6c_");
+    /* x70_ */
+    x70_ = __dna_docin.readFloat("x70_");
+    /* xc4_ */
+    size_t __xc4_Count;
+    __dna_docin.enterSubVector("xc4_", __xc4_Count);
+    /* xc4_[0] */
+    xc4_[0] = __dna_docin.readFloat("xc4_");
+    /* xc4_[1] */
+    xc4_[1] = __dna_docin.readFloat("xc4_");
+    /* xc4_[2] */
+    xc4_[2] = __dna_docin.readFloat("xc4_");
+    /* xc4_[3] */
+    xc4_[3] = __dna_docin.readFloat("xc4_");
+    /* xc4_[4] */
+    xc4_[4] = __dna_docin.readFloat("xc4_");
+    /* xc4_[5] */
+    xc4_[5] = __dna_docin.readFloat("xc4_");
+    /* xc4_[6] */
+    xc4_[6] = __dna_docin.readFloat("xc4_");
+    /* xc4_[7] */
+    xc4_[7] = __dna_docin.readFloat("xc4_");
+    /*  */
+    __dna_docin.leaveSubVector();
+    /* xe4_ */
+    xe4_ = __dna_docin.readFloat("xe4_");
+    /* xe8_ */
+    xe8_ = __dna_docin.readFloat("xe8_");
+    /* x14c_ */
+    x14c_ = __dna_docin.readFloat("x14c_");
+    /* x150_ */
+    x150_ = __dna_docin.readFloat("x150_");
+    /* x158_ */
+    x158_ = __dna_docin.readFloat("x158_");
+    /* x1dc_ */
+    x1dc_ = __dna_docin.readFloat("x1dc_");
+    /* x1e0_ */
+    x1e0_ = __dna_docin.readFloat("x1e0_");
+    /* x1ec_ */
+    x1ec_ = __dna_docin.readFloat("x1ec_");
+    /* x1f0_ */
+    x1f0_ = __dna_docin.readFloat("x1f0_");
+    /* x1f4_ */
+    x1f4_ = __dna_docin.readFloat("x1f4_");
+    /* x1f8_ */
+    x1f8_ = __dna_docin.readFloat("x1f8_");
+    /* x1fc_ */
+    x1fc_ = __dna_docin.readFloat("x1fc_");
+    /* x74_ */
+    x74_ = __dna_docin.readFloat("x74_");
+    /* x78_ */
+    x78_ = __dna_docin.readVec3f("x78_");
+    /* x84_ */
+    x84_ = __dna_docin.readFloat("x84_");
+    /* x88_ */
+    x88_ = __dna_docin.readFloat("x88_");
+    /* x8c_ */
+    x8c_ = __dna_docin.readFloat("x8c_");
+    /* x90_ */
+    x90_ = __dna_docin.readFloat("x90_");
+    /* x94_ */
+    x94_ = __dna_docin.readFloat("x94_");
+    /* x98_ */
+    x98_ = __dna_docin.readFloat("x98_");
+    /* x9c_ */
+    x9c_ = __dna_docin.readFloat("x9c_");
+    /* xa0_ */
+    xa0_ = __dna_docin.readFloat("xa0_");
+    /* xa4_ */
+    xa4_ = __dna_docin.readFloat("xa4_");
+    /* xa8_ */
+    xa8_ = __dna_docin.readFloat("xa8_");
+    /* xac_ */
+    xac_ = __dna_docin.readFloat("xac_");
+    /* xb0_ */
+    xb0_ = __dna_docin.readFloat("xb0_");
+    /* xb4_ */
+    xb4_ = __dna_docin.readFloat("xb4_");
+    /* xb8_ */
+    xb8_ = __dna_docin.readFloat("xb8_");
+    /* xbc_ */
+    xbc_ = __dna_docin.readFloat("xbc_");
+    /* xc0_ */
+    xc0_ = __dna_docin.readFloat("xc0_");
+    /* x154_ */
+    x154_ = __dna_docin.readFloat("x154_");
+    /* x15c_ */
+    x15c_ = __dna_docin.readFloat("x15c_");
+    /* x160_ */
+    x160_ = __dna_docin.readFloat("x160_");
+    /* x164_ */
+    x164_ = __dna_docin.readFloat("x164_");
+    /* x168_ */
+    x168_ = __dna_docin.readFloat("x168_");
+    /* x16c_ */
+    x16c_ = __dna_docin.readFloat("x16c_");
+    /* x170_ */
+    x170_ = __dna_docin.readFloat("x170_");
+    /* x174_ */
+    x174_ = __dna_docin.readFloat("x174_");
+    /* x178_ */
+    x178_ = __dna_docin.readFloat("x178_");
+    /* x17c_ */
+    x17c_ = __dna_docin.readFloat("x17c_");
+    /* x180_ */
+    x180_ = __dna_docin.readFloat("x180_");
+    /* x184_ */
+    x184_ = __dna_docin.readFloat("x184_");
+    /* x188_ */
+    x188_ = __dna_docin.readFloat("x188_");
+    /* x18c_ */
+    x18c_ = __dna_docin.readVec3f("x18c_");
+    /* x198_ */
+    x198_ = __dna_docin.readFloat("x198_");
+    /* x19c_ */
+    x19c_ = __dna_docin.readFloat("x19c_");
+    /* x1a0_ */
+    x1a0_ = __dna_docin.readFloat("x1a0_");
+    /* x1a4_ */
+    x1a4_ = __dna_docin.readFloat("x1a4_");
+    /* x1a8_ */
+    x1a8_ = __dna_docin.readFloat("x1a8_");
+    /* x1ac_ */
+    x1ac_ = __dna_docin.readFloat("x1ac_");
+    /* x1b0_ */
+    x1b0_ = __dna_docin.readFloat("x1b0_");
+    /* x1b4_ */
+    x1b4_ = __dna_docin.readFloat("x1b4_");
+    /* x1b8_ */
+    x1b8_ = __dna_docin.readVec3f("x1b8_");
+    /* x1c4_ */
+    x1c4_ = __dna_docin.readFloat("x1c4_");
+    /* x1c8_ */
+    x1c8_ = __dna_docin.readFloat("x1c8_");
+    /* x1cc_ */
+    x1cc_ = __dna_docin.readFloat("x1cc_");
+    /* x1d0_ */
+    x1d0_ = __dna_docin.readFloat("x1d0_");
+    /* x1d4_ */
+    x1d4_ = __dna_docin.readFloat("x1d4_");
+    /* x1d8_ */
+    x1d8_ = __dna_docin.readFloat("x1d8_");
+    /* x1e4_ */
+    x1e4_ = __dna_docin.readFloat("x1e4_");
+    /* x1e8_ */
+    x1e8_ = __dna_docin.readFloat("x1e8_");
+    /* x200_ */
+    x200_ = __dna_docin.readFloat("x200_");
+    /* x204_ */
+    x204_ = __dna_docin.readFloat("x204_");
+    /* x20c_ */
+    x20c_ = __dna_docin.readFloat("x20c_");
+    /* x218_ */
+    x218_ = __dna_docin.readFloat("x218_");
+    /* x21c_ */
+    x21c_ = __dna_docin.readFloat("x21c_");
+    /* x220_ */
+    x220_ = __dna_docin.readFloat("x220_");
+    /* x224_ */
+    x224_ = __dna_docin.readFloat("x224_");
+    /* x210_ */
+    x210_ = __dna_docin.readFloat("x210_");
+    /* x22c_ */
+    x22c_ = __dna_docin.readFloat("x22c_");
+    /* x230_ */
+    x230_ = __dna_docin.readFloat("x230_");
+    /* x234_ */
+    x234_ = __dna_docin.readFloat("x234_");
+}
+
+void CTweakBall::write(athena::io::YAMLDocWriter& __dna_docout) const
+{
+    /* x4_ */
+    __dna_docout.enterSubVector("x4_");
+    /* x4_[0] */
+    __dna_docout.writeFloat("x4_", x4_[0]);
+    /* x4_[1] */
+    __dna_docout.writeFloat("x4_", x4_[1]);
+    /* x4_[2] */
+    __dna_docout.writeFloat("x4_", x4_[2]);
+    /* x4_[3] */
+    __dna_docout.writeFloat("x4_", x4_[3]);
+    /* x4_[4] */
+    __dna_docout.writeFloat("x4_", x4_[4]);
+    /* x4_[5] */
+    __dna_docout.writeFloat("x4_", x4_[5]);
+    /* x4_[6] */
+    __dna_docout.writeFloat("x4_", x4_[6]);
+    /* x4_[7] */
+    __dna_docout.writeFloat("x4_", x4_[7]);
+    /*  */
+    __dna_docout.leaveSubVector();
+    /* x24_ */
+    __dna_docout.enterSubVector("x24_");
+    /* x24_[0] */
+    __dna_docout.writeFloat("x24_", x24_[0]);
+    /* x24_[1] */
+    __dna_docout.writeFloat("x24_", x24_[1]);
+    /* x24_[2] */
+    __dna_docout.writeFloat("x24_", x24_[2]);
+    /* x24_[3] */
+    __dna_docout.writeFloat("x24_", x24_[3]);
+    /* x24_[4] */
+    __dna_docout.writeFloat("x24_", x24_[4]);
+    /* x24_[5] */
+    __dna_docout.writeFloat("x24_", x24_[5]);
+    /* x24_[6] */
+    __dna_docout.writeFloat("x24_", x24_[6]);
+    /* x24_[7] */
+    __dna_docout.writeFloat("x24_", x24_[7]);
+    /*  */
+    __dna_docout.leaveSubVector();
+    /* x44_ */
+    __dna_docout.enterSubVector("x44_");
+    /* x44_[0] */
+    __dna_docout.writeFloat("x44_", x44_[0]);
+    /* x44_[1] */
+    __dna_docout.writeFloat("x44_", x44_[1]);
+    /* x44_[2] */
+    __dna_docout.writeFloat("x44_", x44_[2]);
+    /* x44_[3] */
+    __dna_docout.writeFloat("x44_", x44_[3]);
+    /* x44_[4] */
+    __dna_docout.writeFloat("x44_", x44_[4]);
+    /* x44_[5] */
+    __dna_docout.writeFloat("x44_", x44_[5]);
+    /* x44_[6] */
+    __dna_docout.writeFloat("x44_", x44_[6]);
+    /* x44_[7] */
+    __dna_docout.writeFloat("x44_", x44_[7]);
+    /*  */
+    __dna_docout.leaveSubVector();
+    /* x64_ */
+    __dna_docout.writeFloat("x64_", x64_);
+    /* x68_ */
+    __dna_docout.writeFloat("x68_", x68_);
+    /* x6c_ */
+    __dna_docout.writeFloat("x6c_", x6c_);
+    /* x70_ */
+    __dna_docout.writeFloat("x70_", x70_);
+    /* xc4_ */
+    __dna_docout.enterSubVector("xc4_");
+    /* xc4_[0] */
+    __dna_docout.writeFloat("xc4_", xc4_[0]);
+    /* xc4_[1] */
+    __dna_docout.writeFloat("xc4_", xc4_[1]);
+    /* xc4_[2] */
+    __dna_docout.writeFloat("xc4_", xc4_[2]);
+    /* xc4_[3] */
+    __dna_docout.writeFloat("xc4_", xc4_[3]);
+    /* xc4_[4] */
+    __dna_docout.writeFloat("xc4_", xc4_[4]);
+    /* xc4_[5] */
+    __dna_docout.writeFloat("xc4_", xc4_[5]);
+    /* xc4_[6] */
+    __dna_docout.writeFloat("xc4_", xc4_[6]);
+    /* xc4_[7] */
+    __dna_docout.writeFloat("xc4_", xc4_[7]);
+    /*  */
+    __dna_docout.leaveSubVector();
+    /* xe4_ */
+    __dna_docout.writeFloat("xe4_", xe4_);
+    /* xe8_ */
+    __dna_docout.writeFloat("xe8_", xe8_);
+    /* x14c_ */
+    __dna_docout.writeFloat("x14c_", x14c_);
+    /* x150_ */
+    __dna_docout.writeFloat("x150_", x150_);
+    /* x158_ */
+    __dna_docout.writeFloat("x158_", x158_);
+    /* x1dc_ */
+    __dna_docout.writeFloat("x1dc_", x1dc_);
+    /* x1e0_ */
+    __dna_docout.writeFloat("x1e0_", x1e0_);
+    /* x1ec_ */
+    __dna_docout.writeFloat("x1ec_", x1ec_);
+    /* x1f0_ */
+    __dna_docout.writeFloat("x1f0_", x1f0_);
+    /* x1f4_ */
+    __dna_docout.writeFloat("x1f4_", x1f4_);
+    /* x1f8_ */
+    __dna_docout.writeFloat("x1f8_", x1f8_);
+    /* x1fc_ */
+    __dna_docout.writeFloat("x1fc_", x1fc_);
+    /* x74_ */
+    __dna_docout.writeFloat("x74_", x74_);
+    /* x78_ */
+    __dna_docout.writeVec3f("x78_", x78_);
+    /* x84_ */
+    __dna_docout.writeFloat("x84_", x84_);
+    /* x88_ */
+    __dna_docout.writeFloat("x88_", x88_);
+    /* x8c_ */
+    __dna_docout.writeFloat("x8c_", x8c_);
+    /* x90_ */
+    __dna_docout.writeFloat("x90_", x90_);
+    /* x94_ */
+    __dna_docout.writeFloat("x94_", x94_);
+    /* x98_ */
+    __dna_docout.writeFloat("x98_", x98_);
+    /* x9c_ */
+    __dna_docout.writeFloat("x9c_", x9c_);
+    /* xa0_ */
+    __dna_docout.writeFloat("xa0_", xa0_);
+    /* xa4_ */
+    __dna_docout.writeFloat("xa4_", xa4_);
+    /* xa8_ */
+    __dna_docout.writeFloat("xa8_", xa8_);
+    /* xac_ */
+    __dna_docout.writeFloat("xac_", xac_);
+    /* xb0_ */
+    __dna_docout.writeFloat("xb0_", xb0_);
+    /* xb4_ */
+    __dna_docout.writeFloat("xb4_", xb4_);
+    /* xb8_ */
+    __dna_docout.writeFloat("xb8_", xb8_);
+    /* xbc_ */
+    __dna_docout.writeFloat("xbc_", xbc_);
+    /* xc0_ */
+    __dna_docout.writeFloat("xc0_", xc0_);
+    /* x154_ */
+    __dna_docout.writeFloat("x154_", x154_);
+    /* x15c_ */
+    __dna_docout.writeFloat("x15c_", x15c_);
+    /* x160_ */
+    __dna_docout.writeFloat("x160_", x160_);
+    /* x164_ */
+    __dna_docout.writeFloat("x164_", x164_);
+    /* x168_ */
+    __dna_docout.writeFloat("x168_", x168_);
+    /* x16c_ */
+    __dna_docout.writeFloat("x16c_", x16c_);
+    /* x170_ */
+    __dna_docout.writeFloat("x170_", x170_);
+    /* x174_ */
+    __dna_docout.writeFloat("x174_", x174_);
+    /* x178_ */
+    __dna_docout.writeFloat("x178_", x178_);
+    /* x17c_ */
+    __dna_docout.writeFloat("x17c_", x17c_);
+    /* x180_ */
+    __dna_docout.writeFloat("x180_", x180_);
+    /* x184_ */
+    __dna_docout.writeFloat("x184_", x184_);
+    /* x188_ */
+    __dna_docout.writeFloat("x188_", x188_);
+    /* x18c_ */
+    __dna_docout.writeVec3f("x18c_", x18c_);
+    /* x198_ */
+    __dna_docout.writeFloat("x198_", x198_);
+    /* x19c_ */
+    __dna_docout.writeFloat("x19c_", x19c_);
+    /* x1a0_ */
+    __dna_docout.writeFloat("x1a0_", x1a0_);
+    /* x1a4_ */
+    __dna_docout.writeFloat("x1a4_", x1a4_);
+    /* x1a8_ */
+    __dna_docout.writeFloat("x1a8_", x1a8_);
+    /* x1ac_ */
+    __dna_docout.writeFloat("x1ac_", x1ac_);
+    /* x1b0_ */
+    __dna_docout.writeFloat("x1b0_", x1b0_);
+    /* x1b4_ */
+    __dna_docout.writeFloat("x1b4_", x1b4_);
+    /* x1b8_ */
+    __dna_docout.writeVec3f("x1b8_", x1b8_);
+    /* x1c4_ */
+    __dna_docout.writeFloat("x1c4_", x1c4_);
+    /* x1c8_ */
+    __dna_docout.writeFloat("x1c8_", x1c8_);
+    /* x1cc_ */
+    __dna_docout.writeFloat("x1cc_", x1cc_);
+    /* x1d0_ */
+    __dna_docout.writeFloat("x1d0_", x1d0_);
+    /* x1d4_ */
+    __dna_docout.writeFloat("x1d4_", x1d4_);
+    /* x1d8_ */
+    __dna_docout.writeFloat("x1d8_", x1d8_);
+    /* x1e4_ */
+    __dna_docout.writeFloat("x1e4_", x1e4_);
+    /* x1e8_ */
+    __dna_docout.writeFloat("x1e8_", x1e8_);
+    /* x200_ */
+    __dna_docout.writeFloat("x200_", x200_);
+    /* x204_ */
+    __dna_docout.writeFloat("x204_", x204_);
+    /* x20c_ */
+    __dna_docout.writeFloat("x20c_", x20c_);
+    /* x218_ */
+    __dna_docout.writeFloat("x218_", x218_);
+    /* x21c_ */
+    __dna_docout.writeFloat("x21c_", x21c_);
+    /* x220_ */
+    __dna_docout.writeFloat("x220_", x220_);
+    /* x224_ */
+    __dna_docout.writeFloat("x224_", x224_);
+    /* x210_ */
+    __dna_docout.writeFloat("x210_", x210_);
+    /* x22c_ */
+    __dna_docout.writeFloat("x22c_", x22c_);
+    /* x230_ */
+    __dna_docout.writeFloat("x230_", x230_);
+    /* x234_ */
+    __dna_docout.writeFloat("x234_", x234_);
+}
+
+const char* CTweakBall::DNAType()
+{
+    return "DataSpec::DNAMP1::CTweakBall";
+}
+
+size_t CTweakBall::binarySize(size_t __isz) const
+{
+    return __isz + 456;
+}
+
+}
+}
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakBall.hpp b/DataSpec/DNAMP1/Tweaks/CTweakBall.hpp
new file mode 100644
index 000000000..89a07dc74
--- /dev/null
+++ b/DataSpec/DNAMP1/Tweaks/CTweakBall.hpp
@@ -0,0 +1,121 @@
+#ifndef __DNAMP1_CTWEAKBALL_HPP__
+#define __DNAMP1_CTWEAKBALL_HPP__
+
+#include "../../DNACommon/Tweaks/ITweakBall.hpp"
+#include "zeus/CVector3f.hpp"
+
+namespace DataSpec
+{
+namespace DNAMP1
+{
+struct CTweakBall : public ITweakBall
+{
+    DECL_YAML
+    Delete __d;
+    Value<float> x4_[8];
+    Value<float> x24_[8];
+    Value<float> x44_[8];
+    Value<float> x64_;
+    Value<float> x68_;
+    Value<float> x6c_;
+    Value<float> x70_;
+    Value<float> x74_;
+    Value<zeus::CVector3f> x78_;
+    Value<float> x84_;
+    Value<float> x88_;
+    Value<float> x8c_;
+    Value<float> x90_;
+    Value<float> x94_;
+    Value<float> x98_;
+    Value<float> x9c_;
+    Value<float> xa0_;
+    Value<float> xa4_;
+    Value<float> xa8_;
+    Value<float> xac_;
+    Value<float> xb0_;
+    Value<float> xb4_;
+    Value<float> xb8_;
+    Value<float> xbc_;
+    Value<float> xc0_;
+    Value<float> xc4_[8];
+    Value<float> xe4_;
+    Value<float> xe8_;
+    float xec_ = 10000.f;
+    float xf0_ = 1000.f;
+    float xf4_ = 40000.f;
+    float xf8_ = 40000.f;
+    float xfc_ = 40000.f;
+    float x100_ = 40000.f;
+    float x104_ = 40000.f;
+    float x108_ = 40000.f;
+    float x10c_ = 10000.f;
+    float x110_ = 1000.f;
+    float x114_ = 40000.f;
+    float x118_ = 40000.f;
+    float x11c_ = 40000.f;
+    float x120_ = 40000.f;
+    float x124_ = 40000.f;
+    float x128_ = 40000.f;
+    float x12c_ = 10000.f;
+    float x130_ = 10000.f;
+    Value<float> x14c_;
+    Value<float> x150_;
+    Value<float> x158_;
+    Value<float> x154_;
+    Value<float> x15c_;
+    Value<float> x160_;
+    Value<float> x164_;
+    Value<float> x168_;
+    Value<float> x16c_;
+    Value<float> x170_;
+    Value<float> x174_;
+    Value<float> x178_;
+    Value<float> x17c_;
+    Value<float> x180_;
+    Value<float> x184_;
+    Value<float> x188_;
+    Value<zeus::CVector3f> x18c_;
+    Value<float> x198_;
+    Value<float> x19c_;
+    Value<float> x1a0_;
+    Value<float> x1a4_;
+    Value<float> x1a8_;
+    Value<float> x1ac_;
+    Value<float> x1b0_;
+    Value<float> x1b4_;
+    Value<zeus::CVector3f> x1b8_;
+    Value<float> x1c4_;
+    Value<float> x1c8_;
+    Value<float> x1cc_;
+    Value<float> x1d0_;
+    Value<float> x1d4_;
+    Value<float> x1d8_;
+    Value<float> x1dc_;
+    Value<float> x1e0_;
+    Value<float> x1ec_;
+    Value<float> x1f0_;
+    Value<float> x1f4_;
+    Value<float> x1f8_;
+    Value<float> x1fc_;
+    Value<float> x1e4_;
+    Value<float> x1e8_;
+    Value<float> x200_;
+    Value<float> x204_;
+    float x208_;
+    Value<float> x20c_;
+    Value<float> x218_;
+    Value<float> x21c_;
+    Value<float> x220_;
+    Value<float> x224_;
+    Value<float> x210_;
+    float x228_;
+    Value<float> x22c_;
+    Value<float> x230_;
+    Value<float> x234_;
+
+    CTweakBall()=default;
+    CTweakBall(athena::io::IStreamReader& r) { this->read(r); }
+};
+}
+}
+#endif // __DNAMP1_CTWEAKBALL_HPP__
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp b/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
index 18070492f..ecf6b0339 100644
--- a/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
+++ b/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
@@ -119,7 +119,7 @@ struct CTweakGui : ITweakGui
     Value<float> x1f4_;
     Value<float> x1f8_;
     Value<float> x1fc_;
-    atVec4f x200_;
+    float x200_;
     float x204_xrayBlurScaleLinear = 0.0014f;
     float x208_xrayBlurScaleQuadratic = 0.0000525f;
     Value<float> x20c_;
@@ -149,23 +149,23 @@ struct CTweakGui : ITweakGui
     Value<float> x26c_;
     Value<float> x270_;
     Value<bool> x274_;
-    Value<bool> x275_ = true;
+    bool x275_ = true;
     Value<float> x278_;
     Value<atUint32> x27c_;
     Value<float> x280_;
     Value<float> x284_;
-    Value<atVec4f> x288_;
+    DNAColor x288_;
     Value<float> x28c_;
-    Value<atVec4f> x290_;
-    Value<atVec4f> x294_;
-    Value<atVec4f> x298_;
-    Value<atVec4f> x29c_;
-    Value<atVec4f> x2a0_;
-    Value<atVec4f> x2a4_;
-    Value<atVec4f> x2a8_;
-    Value<atVec4f> x2ac_;
-    Value<atVec4f> x2b0_;
-    Value<atVec4f> x2b4_;
+    DNAColor x290_;
+    DNAColor x294_;
+    DNAColor x298_;
+    DNAColor x29c_;
+    DNAColor x2a0_;
+    DNAColor x2a4_;
+    DNAColor x2a8_;
+    DNAColor x2ac_;
+    DNAColor x2b0_;
+    DNAColor x2b4_;
     Value<float> x2b8_;
     Value<float> x2bc_;
     Value<float> x2c0_;
@@ -174,24 +174,26 @@ struct CTweakGui : ITweakGui
     String<-1> x2d0_;
     String<-1> x2e0_;
     String<-1> x2f0_;
-    Value<atVec4f> x300_;
-    Value<atVec4f> x304_;
+    DNAColor x300_;
+    DNAColor x304_;
     Value<float> x308_;
     Value<float> x30c_;
     Value<float> x310_;
     String<-1> x314_;
     String<-1> x324_;
     String<-1> x334_;
-    Value<atVec4f> x344_;
-    Value<atVec4f> x348_;
-    Value<atVec4f> x34c_;
-    Value<atVec4f> x350_;
-    Value<atVec4f> x354_;
-    Value<atVec4f> x358_;
+    DNAColor x344_;
+    DNAColor x348_;
+    DNAColor x34c_;
+    DNAColor x350_;
+    DNAColor x354_;
+    DNAColor x358_;
     Value<float> x35c_;
     Value<float> x360_;
     Value<float> x364_;
 
+    CTweakGui() = default;
+    CTweakGui(athena::io::IStreamReader& r) { this->read(r); }
     float GetXrayBlurScaleLinear() const { return x204_xrayBlurScaleLinear; }
     float GetXrayBlurScaleQuadratic() const { return x208_xrayBlurScaleQuadratic; }
 
@@ -207,10 +209,9 @@ struct CTweakGui : ITweakGui
         xd8_ = zeus::degToRad(xd8_);
         xdc_ = zeus::degToRad(xdc_);
 
-        x200_.vec[0] = x1f4_ * 0.25f;
-        x200_.vec[1] = x1f8_ * 0.25f;
-        x200_.vec[2] = x1fc_ * 0.25f;
-        x200_.vec[3] = 1.f;
+        x200_ = x1f4_ * 0.25f;
+        x204_xrayBlurScaleLinear = x1f8_ * 0.25f;
+        x208_xrayBlurScaleQuadratic = x1fc_ * 0.25f;
 
         x210_ = zeus::degToRad(x210_);
         x228_ = x220_ + x224_;
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp b/DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp
new file mode 100644
index 000000000..960ebf310
--- /dev/null
+++ b/DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp
@@ -0,0 +1,145 @@
+#ifndef __DNAMP1_CTWEAKGUICOLORS_HPP__
+#define __DNAMP1_CTWEAKGUICOLORS_HPP__
+
+#include "../../DNACommon/Tweaks/ITweakGuiColors.hpp"
+
+namespace DataSpec
+{
+namespace DNAMP1
+{
+struct CTweakGuiColors : public ITweakGuiColors
+{
+    DECL_YAML
+    DNAColor x4_;
+    DNAColor x8_;
+    DNAColor xc_;
+    DNAColor x10_;
+    DNAColor x14_;
+    DNAColor x18_;
+    DNAColor x1c_;
+    DNAColor x20_;
+    DNAColor x24_;
+    DNAColor x28_;
+    DNAColor x2c_;
+    DNAColor x30_;
+    DNAColor x34_;
+    DNAColor x38_;
+    DNAColor x3c_;
+    DNAColor x40_;
+    DNAColor x44_;
+    DNAColor x48_;
+    DNAColor x4c_;
+    DNAColor x50_;
+    DNAColor x54_;
+    DNAColor x58_;
+    DNAColor x5c_;
+    DNAColor x60_;
+    DNAColor x64_;
+    DNAColor x68_;
+    DNAColor x6c_;
+    DNAColor x70_;
+    DNAColor x74_;
+    DNAColor x78_;
+    DNAColor x7c_;
+    DNAColor x80_;
+    DNAColor x84_;
+    DNAColor x88_;
+    DNAColor x8c_;
+    DNAColor x90_;
+    DNAColor x94_;
+    DNAColor x98_;
+    DNAColor x9c_;
+    DNAColor xa0_;
+    DNAColor xa4_;
+    DNAColor xa8_;
+    DNAColor xac_;
+    DNAColor xb0_;
+    DNAColor xb4_;
+    DNAColor xb8_;
+    DNAColor xbc_;
+    DNAColor xc0_;
+    DNAColor xc4_;
+    DNAColor xc8_;
+    DNAColor xcc_;
+    DNAColor xd0_;
+    DNAColor xd4_;
+    DNAColor xd8_;
+    DNAColor xdc_;
+    DNAColor xe0_;
+    DNAColor xe4_;
+    DNAColor xe8_;
+    DNAColor xec_;
+    DNAColor xf0_;
+    DNAColor xf4_;
+    DNAColor xf8_;
+    DNAColor xfc_;
+    DNAColor x100_;
+    DNAColor x104_;
+    DNAColor x108_;
+    DNAColor x10c_;
+    DNAColor x110_;
+    DNAColor x114_;
+    DNAColor x118_;
+    DNAColor x11c_;
+    DNAColor x120_;
+    DNAColor x124_;
+    DNAColor x128_;
+    DNAColor x12c_;
+    DNAColor x130_;
+    DNAColor x134_;
+    DNAColor x138_;
+    DNAColor x13c_;
+    DNAColor x140_;
+    DNAColor x144_;
+    DNAColor x148_;
+    DNAColor x14c_;
+    DNAColor x150_;
+    DNAColor x154_;
+    DNAColor x158_;
+    DNAColor x15c_;
+    DNAColor x160_;
+    DNAColor x164_;
+    DNAColor x168_;
+    DNAColor x16c_;
+    DNAColor x170_;
+    DNAColor x174_;
+    DNAColor x178_;
+    DNAColor x17c_;
+    DNAColor x180_;
+    DNAColor x184_;
+    DNAColor x188_;
+    DNAColor x18c_;
+    DNAColor x190_;
+    DNAColor x194_;
+    DNAColor x198_;
+    DNAColor x19c_;
+    DNAColor x1a0_;
+    DNAColor x1a4_;
+    DNAColor x1a8_;
+    DNAColor x1ac_;
+    DNAColor x1b0_;
+    DNAColor x1b4_;
+    DNAColor x1b8_;
+    DNAColor x1bc_;
+    DNAColor x1c0_;
+    struct UnkColors : BigYAML
+    {
+        DECL_YAML
+        DNAColor x0_;
+        DNAColor x4_;
+        DNAColor x8_;
+        DNAColor xc_;
+        DNAColor x10_;
+        DNAColor x14_;
+        DNAColor x18_;
+    };
+    Value<atUint32> x1c4_count;
+    Vector<UnkColors, DNA_COUNT(x1c4_count)> x1c4_;
+
+    CTweakGuiColors() = default;
+    CTweakGuiColors(athena::io::IStreamReader& r) { this->read(r); }
+};
+}
+}
+
+#endif // __DNAMP1_CTWEAKGUICOLORS_HPP__
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp b/DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp
index ee60f0c03..ea93b613c 100644
--- a/DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp
+++ b/DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp
@@ -15,6 +15,7 @@ struct CTweakParticle : ITweakParticle
     String<-1> m_powerBeam;
     String<-1> m_genThrust;
 
+    CTweakParticle()=default;
     CTweakParticle(athena::io::IStreamReader& reader) { this->read(reader); }
 };
 
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp b/DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp
index 480fd9aa2..d42383066 100644
--- a/DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp
+++ b/DataSpec/DNAMP1/Tweaks/CTweakPlayerControl.hpp
@@ -13,6 +13,7 @@ struct CTweakPlayerControl : ITweakPlayerControl
     DECL_YAML
     Vector<atUint32, DNA_COUNT(65)> m_mappings;
     atUint32 GetMapping(atUint32 command) const {return m_mappings[command];}
+    CTweakPlayerControl() = default;
     CTweakPlayerControl(athena::io::IStreamReader& reader) {this->read(reader);}
 };
 
diff --git a/DataSpec/SpecMP1.cpp b/DataSpec/SpecMP1.cpp
index 63dff7619..91f67eae8 100644
--- a/DataSpec/SpecMP1.cpp
+++ b/DataSpec/SpecMP1.cpp
@@ -29,6 +29,13 @@
 #include "DNAMP1/Tweaks/CTweakPlayer.hpp"
 #include "DNAMP1/Tweaks/CTweakCameraBob.hpp"
 #include "DNAMP1/Tweaks/CTweakGame.hpp"
+#include "DNAMP1/Tweaks/CTweakTargeting.hpp"
+#include "DNAMP1/Tweaks/CTweakAutoMapper.hpp"
+#include "DNAMP1/Tweaks/CTweakGui.hpp"
+#include "DNAMP1/Tweaks/CTweakPlayerControl.hpp"
+#include "DNAMP1/Tweaks/CTweakBall.hpp"
+#include "DNAMP1/Tweaks/CTweakParticle.hpp"
+#include "DNAMP1/Tweaks/CTweakGuiColors.hpp"
 
 #include "hecl/ClientProcess.hpp"
 
@@ -372,6 +379,20 @@ struct SpecMP1 : SpecBase
                 return true;
             else if (!strcmp(classType, DNAMP1::CTweakGame::DNAType()))
                 return true;
+            else if (!strcmp(classType, DNAMP1::CTweakAutoMapper::DNAType()))
+                return true;
+            else if (!strcmp(classType, DNAMP1::CTweakTargeting::DNAType()))
+                return true;
+            else if (!strcmp(classType, DNAMP1::CTweakGui::DNAType()))
+                return true;
+            else if (!strcmp(classType, DNAMP1::CTweakPlayerControl::DNAType()))
+                return true;
+            else if (!strcmp(classType, DNAMP1::CTweakBall::DNAType()))
+                return true;
+            else if (!strcmp(classType, DNAMP1::CTweakParticle::DNAType()))
+                return true;
+            else if (!strcmp(classType, DNAMP1::CTweakGuiColors::DNAType()))
+                return true;
             else if (!strcmp(classType, DNAMP1::HINT::DNAType()))
                 return true;
             else if (!strcmp(classType, "ATBL"))
@@ -524,7 +545,14 @@ struct SpecMP1 : SpecBase
                          !strcmp(className, "DataSpec::DNAMP1::CTweakSlideShow") ||
                          !strcmp(className, "DataSpec::DNAMP1::CTweakPlayer") ||
                          !strcmp(className, "DataSpec::DNAMP1::CTweakCameraBob") ||
-                         !strcmp(className, "DataSpec::DNAMP1::CTweakGame"))
+                         !strcmp(className, "DataSpec::DNAMP1::CTweakGame") ||
+                         !strcmp(className, "DataSpec::DNAMP1::CTweakTargeting") ||
+                         !strcmp(className, "DataSpec::DNAMP1::CTweakAutoMapper") ||
+                         !strcmp(className, "DataSpec::DNAMP1::CTweakGui") ||
+                         !strcmp(className, "DataSpec::DNAMP1::CTweakPlayerControl") ||
+                         !strcmp(className, "DataSpec::DNAMP1::CTweakBall") ||
+                         !strcmp(className, "DataSpec::DNAMP1::CTweakParticle") ||
+                         !strcmp(className, "DataSpec::DNAMP1::CTweakGuiColors"))
                 {
                     resTag.type = SBIG('CTWK');
                     return true;
@@ -739,6 +767,42 @@ struct SpecMP1 : SpecBase
                 cGame.read(reader);
                 WriteTweak(cGame, out);
             }
+            else if (!classStr.compare(DNAMP1::CTweakAutoMapper::DNAType()))
+            {
+                DNAMP1::CTweakAutoMapper autoMapper;
+                autoMapper.read(reader);
+                WriteTweak(autoMapper, out);
+            }
+            else if (!classStr.compare(DNAMP1::CTweakTargeting::DNAType()))
+            {
+                DNAMP1::CTweakTargeting targeting;
+                targeting.read(reader);
+                WriteTweak(targeting, out);
+            }
+            else if (!classStr.compare(DNAMP1::CTweakGui::DNAType()))
+            {
+                DNAMP1::CTweakGui gui;
+                gui.read(reader);
+                WriteTweak(gui, out);
+            }
+            else if (!classStr.compare(DNAMP1::CTweakBall::DNAType()))
+            {
+                DNAMP1::CTweakBall ball;
+                ball.read(reader);
+                WriteTweak(ball, out);
+            }
+            else if (!classStr.compare(DNAMP1::CTweakParticle::DNAType()))
+            {
+                DNAMP1::CTweakParticle part;
+                part.read(reader);
+                WriteTweak(part, out);
+            }
+            else if (!classStr.compare(DNAMP1::CTweakGuiColors::DNAType()))
+            {
+                DNAMP1::CTweakGuiColors gColors;
+                gColors.read(reader);
+                WriteTweak(gColors, out);
+            }
             else if (!classStr.compare(DNAMP1::HINT::DNAType()))
             {
                 DNAMP1::HINT::Cook(in, out);
diff --git a/Editor/ProjectResourceFactoryBase.cpp b/Editor/ProjectResourceFactoryBase.cpp
index a88d4b628..48dcf4f8f 100644
--- a/Editor/ProjectResourceFactoryBase.cpp
+++ b/Editor/ProjectResourceFactoryBase.cpp
@@ -509,8 +509,7 @@ void ProjectResourceFactoryBase::AsyncTask::CookComplete()
     /* Ready for buffer transaction at this point */
     u32 availSz = std::max(0, s32(fr.length()) - s32(x14_resOffset));
     x14_resSize = std::min(x14_resSize, availSz);
-    u8* derp = new u8[x14_resSize];
-    x10_loadBuffer.reset(std::move(derp));
+    x10_loadBuffer.reset(new u8[x14_resSize]);
     m_bufTransaction = m_parent.m_clientProc.addBufferTransaction(m_cookedPath,
                                                                   x10_loadBuffer.get(),
                                                                   x14_resSize, x14_resOffset);
diff --git a/Runtime/AutoMapper/CMakeLists.txt b/Runtime/AutoMapper/CMakeLists.txt
index 13f6e9153..cd8d20217 100644
--- a/Runtime/AutoMapper/CMakeLists.txt
+++ b/Runtime/AutoMapper/CMakeLists.txt
@@ -4,7 +4,6 @@ set(AUTOMAPPER_SOURCES
     CMapWorld.hpp CMapWorld.cpp
     CMapArea.hpp CMapArea.cpp
     CMappableObject.hpp CMappableObject.cpp
-    CAutoMapper.hpp CAutoMapper.cpp
-    ITweakAutoMapper.hpp)
+    CAutoMapper.hpp CAutoMapper.cpp)
 
 runtime_add_list(AutoMapper AUTOMAPPER_SOURCES)
diff --git a/Runtime/AutoMapper/CMappableObject.cpp b/Runtime/AutoMapper/CMappableObject.cpp
index f37a0df7e..0f7c32c85 100644
--- a/Runtime/AutoMapper/CMappableObject.cpp
+++ b/Runtime/AutoMapper/CMappableObject.cpp
@@ -1,6 +1,5 @@
 #include "CMappableObject.hpp"
 #include "GameGlobalObjects.hpp"
-#include "ITweakAutoMapper.hpp"
 
 namespace urde
 {
diff --git a/Runtime/AutoMapper/CMappableObject.hpp b/Runtime/AutoMapper/CMappableObject.hpp
index 1c24690dc..6a1d02b5f 100644
--- a/Runtime/AutoMapper/CMappableObject.hpp
+++ b/Runtime/AutoMapper/CMappableObject.hpp
@@ -4,12 +4,11 @@
 #include "RetroTypes.hpp"
 #include "zeus/CAABox.hpp"
 #include "zeus/CTransform.hpp"
+#include "GameGlobalObjects.hpp"
 
 namespace urde
 {
 class CStateManager;
-class ITweakAutoMapper;
-
 class CMappableObject
 {
 public:
diff --git a/Runtime/AutoMapper/ITweakAutoMapper.hpp b/Runtime/AutoMapper/ITweakAutoMapper.hpp
deleted file mode 100644
index bb2cc603b..000000000
--- a/Runtime/AutoMapper/ITweakAutoMapper.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef __URDE_ITWEAKAUTOMAPPER_HPP__
-#define __URDE_ITWEAKAUTOMAPPER_HPP__
-
-#include "zeus/CVector3f.hpp"
-#include "ITweak.hpp"
-
-namespace urde
-{
-class ITweakAutoMapper : public ITweak
-{
-public:
-    virtual ~ITweakAutoMapper() {}
-    virtual const zeus::CVector3f& GetDoorCenter() const=0;
-};
-}
-
-#endif // __URDE_ITWEAKAUTOMAPPER_HPP__
diff --git a/Runtime/CScannableObjectInfo.cpp b/Runtime/CScannableObjectInfo.cpp
index cce5dad2f..b7692a148 100644
--- a/Runtime/CScannableObjectInfo.cpp
+++ b/Runtime/CScannableObjectInfo.cpp
@@ -1,6 +1,5 @@
 #include "CScannableObjectInfo.hpp"
 #include "GameGlobalObjects.hpp"
-#include "GuiSys/ITweakGui.hpp"
 
 namespace urde
 {
diff --git a/Runtime/GameGlobalObjects.cpp b/Runtime/GameGlobalObjects.cpp
index 1a545152c..bc738c447 100644
--- a/Runtime/GameGlobalObjects.cpp
+++ b/Runtime/GameGlobalObjects.cpp
@@ -18,15 +18,20 @@ class CInGameTweakManagerBase* g_TweakManager = nullptr;
 class CBooRenderer* g_Renderer = nullptr;
 class CStringTable* g_MainStringTable = nullptr;
 
-DataSpec::ITweakGame*   g_tweakGame = nullptr;
-DataSpec::ITweakPlayer* g_tweakPlayer = nullptr;
-DataSpec::ITweakPlayerControl* g_tweakPlayerControl = nullptr;
-DataSpec::ITweakPlayerControl* g_tweakPlayerControlAlt = nullptr;
-DataSpec::ITweakPlayerControl* g_currentPlayerControl = nullptr;
-DataSpec::ITweakPlayerGun* g_tweakPlayerGun = nullptr;
-DataSpec::ITweakGunRes* g_tweakGunRes = nullptr;
-DataSpec::ITweakPlayerRes* g_tweakPlayerRes = nullptr;
-DataSpec::ITweakGui* g_tweakGui = nullptr;
-DataSpec::ITweakSlideShow* g_tweakSlideShow = nullptr;
+ITweakGame*   g_tweakGame = nullptr;
+ITweakPlayer* g_tweakPlayer = nullptr;
+ITweakPlayerControl* g_tweakPlayerControl = nullptr;
+ITweakPlayerControl* g_tweakPlayerControlAlt = nullptr;
+ITweakPlayerControl* g_currentPlayerControl = nullptr;
+ITweakPlayerGun* g_tweakPlayerGun = nullptr;
+ITweakGunRes* g_tweakGunRes = nullptr;
+ITweakPlayerRes* g_tweakPlayerRes = nullptr;
+ITweakTargeting* g_tweakTargeting = nullptr;
+ITweakAutoMapper* g_tweakAutoMapper = nullptr;
+ITweakGui* g_tweakGui = nullptr;
+ITweakSlideShow* g_tweakSlideShow = nullptr;
+ITweakParticle* g_tweakParticle = nullptr;
+ITweakBall* g_tweakBall = nullptr;
+ITweakGuiColors* g_tweakGuiColors = nullptr;
 
 }
diff --git a/Runtime/GameGlobalObjects.hpp b/Runtime/GameGlobalObjects.hpp
index e82e3e581..647a61c83 100644
--- a/Runtime/GameGlobalObjects.hpp
+++ b/Runtime/GameGlobalObjects.hpp
@@ -8,8 +8,12 @@
 #include "../DataSpec/DNACommon/Tweaks/ITweakPlayerRes.hpp"
 #include "../DataSpec/DNACommon/Tweaks/ITweakGui.hpp"
 #include "../DataSpec/DNACommon/Tweaks/ITweakSlideShow.hpp"
-#include "AutoMapper/ITweakAutoMapper.hpp"
-#include "GuiSys/ITweakGui.hpp"
+#include "../DataSpec/DNACommon/Tweaks/ITweakGui.hpp"
+#include "../DataSpec/DNACommon/Tweaks/ITweakTargeting.hpp"
+#include "../DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp"
+#include "../DataSpec/DNACommon/Tweaks/ITweakParticle.hpp"
+#include "../DataSpec/DNACommon/Tweaks/ITweakBall.hpp"
+#include "../DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp"
 
 namespace urde
 {
@@ -18,7 +22,6 @@ namespace MP1
 {
 extern class CGameArchitectureSupport* g_archSupport;
 }
-
 extern class CMemoryCardSys* g_MemoryCardSys;
 extern class IFactory* g_ResFactory;
 extern class CSimplePool* g_SimplePool;
@@ -29,17 +32,35 @@ extern class CInGameTweakManagerBase* g_TweakManager;
 extern class CBooRenderer* g_Renderer;
 extern class CStringTable* g_MainStringTable;
 
-extern DataSpec::ITweakGame*   g_tweakGame;
-extern DataSpec::ITweakPlayer* g_tweakPlayer;
-extern DataSpec::ITweakPlayerControl* g_tweakPlayerControl;
-extern DataSpec::ITweakPlayerControl* g_tweakPlayerControlAlt;
-extern DataSpec::ITweakPlayerControl* g_currentPlayerControl;
-extern DataSpec::ITweakPlayerGun* g_tweakPlayerGun;
-extern DataSpec::ITweakGunRes* g_tweakGunRes;
-extern DataSpec::ITweakPlayerRes* g_tweakPlayerRes;
+using ITweakGame = DataSpec::ITweakGame;
+using ITweakPlayer = DataSpec::ITweakPlayer;
+using ITweakPlayerRes = DataSpec::ITweakPlayerRes;
+using ITweakPlayerControl = DataSpec::ITweakPlayerControl;
+using ITweakPlayerGun = DataSpec::ITweakPlayerGun;
+using ITweakGunRes = DataSpec::ITweakGunRes;
+using ITweakTargeting = DataSpec::ITweakTargeting;
+using ITweakAutoMapper = DataSpec::ITweakAutoMapper;
+using ITweakGui = DataSpec::ITweakGui;
+using ITweakSlideShow = DataSpec::ITweakSlideShow;
+using ITweakParticle = DataSpec::ITweakParticle;
+using ITweakBall = DataSpec::ITweakBall;
+using ITweakGuiColors = DataSpec::ITweakGuiColors;
+
+extern ITweakGame*   g_tweakGame;
+extern ITweakPlayer* g_tweakPlayer;
+extern ITweakPlayerControl* g_tweakPlayerControl;
+extern ITweakPlayerControl* g_tweakPlayerControlAlt;
+extern ITweakPlayerControl* g_currentPlayerControl;
+extern ITweakPlayerGun* g_tweakPlayerGun;
+extern ITweakGunRes* g_tweakGunRes;
+extern ITweakPlayerRes* g_tweakPlayerRes;
+extern ITweakTargeting* g_tweakTargeting;
 extern ITweakAutoMapper* g_tweakAutoMapper;
-extern DataSpec::ITweakGui* g_tweakGui;
-extern DataSpec::ITweakSlideShow* g_tweakSlideShow;
+extern ITweakGui* g_tweakGui;
+extern ITweakSlideShow* g_tweakSlideShow;
+extern ITweakParticle* g_tweakParticle;
+extern ITweakBall* g_tweakBall;
+extern ITweakGuiColors* g_tweakGuiColors;
 
 }
 
diff --git a/Runtime/GuiSys/CMakeLists.txt b/Runtime/GuiSys/CMakeLists.txt
index 8f2c231b3..9766082a5 100644
--- a/Runtime/GuiSys/CMakeLists.txt
+++ b/Runtime/GuiSys/CMakeLists.txt
@@ -1,77 +1,40 @@
 set(GUISYS_SOURCES
-    CSplashScreen.cpp
-    CSplashScreen.hpp
-    CGuiObject.cpp
-    CGuiObject.hpp
-    CConsoleOutputWindow.cpp
-    CConsoleOutputWindow.hpp
-    CAuiEnergyBarT01.cpp
-    CAuiEnergyBarT01.hpp
-    CAuiImagePane.cpp
-    CAuiImagePane.hpp
-    CAuiMeter.cpp
-    CAuiMeter.hpp
-    CConsoleOutputWindow.cpp
-    CConsoleOutputWindow.hpp
-    CErrorOutputWindow.cpp
-    CErrorOutputWindow.hpp
-    CGuiCamera.cpp
-    CGuiCamera.hpp
-    CGuiFrame.cpp
-    CGuiFrame.hpp
-    CGuiLight.cpp
-    CGuiLight.hpp
-    CGuiModel.cpp
-    CGuiModel.hpp
-    CGuiSliderGroup.cpp
-    CGuiSliderGroup.hpp
-    CGuiSys.cpp
-    CGuiSys.hpp
-    CGuiTableGroup.cpp
-    CGuiTableGroup.hpp
-    CGuiTextPane.cpp
-    CGuiTextPane.hpp
-    CGuiTextSupport.cpp
-    CGuiTextSupport.hpp
-    CGuiWidget.cpp
-    CGuiWidgetDrawParms.cpp
-    CGuiWidgetDrawParms.hpp
-    CGuiWidget.hpp
-    CMakeLists.txt
-    CSplashScreen.cpp
-    CSplashScreen.hpp
-    CGuiCompoundWidget.cpp
-    CGuiCompoundWidget.hpp
-    CSaveableState.cpp
-    CSaveableState.hpp
-    CDrawStringOptions.cpp
-    CDrawStringOptions.hpp
-    CRasterFont.cpp
-    CRasterFont.hpp
-    CGuiGroup.cpp
-    CGuiGroup.hpp
-    CGuiWidgetIdDB.cpp
-    CGuiWidgetIdDB.hpp
-    CGuiHeadWidget.cpp
-    CGuiHeadWidget.hpp
-    CGuiPane.cpp
-    CGuiPane.hpp
-    CFontRenderState.cpp
-    CFontRenderState.hpp
-    CTextExecuteBuffer.cpp
-    CTextExecuteBuffer.hpp
-    CTextRenderBuffer.cpp
-    CTextRenderBuffer.hpp
-    CInstruction.cpp
-    CInstruction.hpp
-    CTextParser.cpp
-    CTextParser.hpp
-    CWordBreakTables.cpp
-    CWordBreakTables.hpp
-    CFontImageDef.cpp
-    CFontImageDef.hpp
-    ITweakGui.hpp
-    CStringTable.cpp
-    CStringTable.hpp)
+    CSplashScreen.hpp CSplashScreen.cpp
+    CGuiObject.hpp CGuiObject.cpp
+    CConsoleOutputWindow.hpp CConsoleOutputWindow.cpp
+    CAuiEnergyBarT01.hpp CAuiEnergyBarT01.cpp
+    CAuiImagePane.hpp CAuiImagePane.cpp
+    CAuiMeter.hpp CAuiMeter.cpp
+    CConsoleOutputWindow.hpp CConsoleOutputWindow.cpp
+    CErrorOutputWindow.hpp CErrorOutputWindow.cpp
+    CGuiCamera.hpp CGuiCamera.cpp
+    CGuiFrame.hpp CGuiFrame.cpp
+    CGuiLight.hpp CGuiLight.cpp
+    CGuiModel.hpp CGuiModel.cpp
+    CGuiSliderGroup.hpp CGuiSliderGroup.cpp
+    CGuiSys.hpp CGuiSys.cpp
+    CGuiTableGroup.hpp CGuiTableGroup.cpp
+    CGuiTextPane.hpp CGuiTextPane.cpp
+    CGuiTextSupport.hpp CGuiTextSupport.cpp
+    CGuiWidget.hpp CGuiWidget.cpp
+    CGuiWidgetDrawParms.hpp CGuiWidgetDrawParms.cpp
+    CSplashScreen.hpp CSplashScreen.cpp
+    CGuiCompoundWidget.hpp CGuiCompoundWidget.cpp
+    CSaveableState.hpp CSaveableState.cpp
+    CDrawStringOptions.hpp CDrawStringOptions.cpp
+    CRasterFont.hpp CRasterFont.cpp
+    CGuiGroup.hpp CGuiGroup.cpp
+    CGuiWidgetIdDB.hpp CGuiWidgetIdDB.cpp
+    CGuiHeadWidget.hpp CGuiHeadWidget.cpp
+    CGuiPane.hpp CGuiPane.cpp
+    CFontRenderState.hpp CFontRenderState.cpp
+    CTextExecuteBuffer.hpp CTextExecuteBuffer.cpp
+    CTextRenderBuffer.hpp CTextRenderBuffer.cpp
+    CInstruction.hpp CInstruction.cpp
+    CTextParser.hpp CTextParser.cpp
+    CWordBreakTables.hpp CWordBreakTables.cpp
+    CFontImageDef.hpp CFontImageDef.cpp
+    CStringTable.hpp CStringTable.cpp
+    CTargetingManager.hpp CTargetingManager.cpp)
 
 runtime_add_list(GuiSys GUISYS_SOURCES)
diff --git a/Runtime/GuiSys/CTargetingManager.cpp b/Runtime/GuiSys/CTargetingManager.cpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/Runtime/GuiSys/CTargetingManager.hpp b/Runtime/GuiSys/CTargetingManager.hpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/Runtime/GuiSys/CTextParser.cpp b/Runtime/GuiSys/CTextParser.cpp
index 309afd61d..0e4fd45d4 100644
--- a/Runtime/GuiSys/CTextParser.cpp
+++ b/Runtime/GuiSys/CTextParser.cpp
@@ -158,7 +158,7 @@ void CTextParser::ParseTag(CTextExecuteBuffer& out, const char16_t* str, int len
             out.AddJustification(EJustification::Center);
         else if (Equals(str + 5, len - 5, u"right"))
             out.AddJustification(EJustification::Right);
-        else if (Equals(str + 5, len - 5, u"fulu"))
+        else if (Equals(str + 5, len - 5, u"full"))
             out.AddJustification(EJustification::Full);
         else if (Equals(str + 5, len - 5, u"nleft"))
             out.AddJustification(EJustification::NLeft);
@@ -175,7 +175,7 @@ void CTextParser::ParseTag(CTextExecuteBuffer& out, const char16_t* str, int len
             out.AddVerticalJustification(EVerticalJustification::Center);
         else if (Equals(str + 6, len - 6, u"bottom"))
             out.AddVerticalJustification(EVerticalJustification::Bottom);
-        else if (Equals(str + 6, len - 6, u"fulu"))
+        else if (Equals(str + 6, len - 6, u"full"))
             out.AddVerticalJustification(EVerticalJustification::Full);
         else if (Equals(str + 6, len - 6, u"ntop"))
             out.AddVerticalJustification(EVerticalJustification::NTop);
diff --git a/Runtime/GuiSys/ITweakGui.hpp b/Runtime/GuiSys/ITweakGui.hpp
deleted file mode 100644
index 349030bd3..000000000
--- a/Runtime/GuiSys/ITweakGui.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef __URDE_ITWEAKGUI_HPP__
-#define __URDE_ITWEAKGUI_HPP__
-
-#include "RetroTypes.hpp"
-#include "ITweak.hpp"
-
-namespace urde
-{
-class ITweakGui : public ITweak
-{
-public:
-    virtual ~ITweakGui() {}
-
-    virtual float GetScanSpeed(s32) const=0;
-};
-}
-
-#endif // __URDE_ITWEAKGUI_HPP__
diff --git a/Runtime/MP1/CMakeLists.txt b/Runtime/MP1/CMakeLists.txt
index 3a1589172..cc0fd6aa2 100644
--- a/Runtime/MP1/CMakeLists.txt
+++ b/Runtime/MP1/CMakeLists.txt
@@ -2,9 +2,6 @@ include_directories(. ..)
 set(MP1_SOURCES
     CTweaks.hpp CTweaks.cpp
     CInGameTweakManager.hpp CInGameTweakManager.cpp
-    Tweaks/CTweakAutoMapper.hpp Tweaks/CTweakAutoMapper.cpp
-    Tweaks/CTweakPlayer.hpp Tweaks/CTweakPlayer.cpp
-    Tweaks/CTweakGui.hpp Tweaks/CTweakGui.cpp
     CGBASupport.hpp CGBASupport.cpp
     CNESEmulator.hpp CNESEmulator.cpp
     CMainFlow.hpp CMainFlow.cpp
diff --git a/Runtime/MP1/CTweaks.cpp b/Runtime/MP1/CTweaks.cpp
index 73ab46595..194830dd2 100644
--- a/Runtime/MP1/CTweaks.cpp
+++ b/Runtime/MP1/CTweaks.cpp
@@ -11,6 +11,12 @@
 #include "DataSpec/DNAMP1/Tweaks/CTweakGunRes.hpp"
 #include "DataSpec/DNAMP1/Tweaks/CTweakPlayerRes.hpp"
 #include "DataSpec/DNAMP1/Tweaks/CTweakSlideShow.hpp"
+#include "DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp"
+#include "DataSpec/DNAMP1/Tweaks/CTweakTargeting.hpp"
+#include "DataSpec/DNAMP1/Tweaks/CTweakGui.hpp"
+#include "DataSpec/DNAMP1/Tweaks/CTweakParticle.hpp"
+#include "DataSpec/DNAMP1/Tweaks/CTweakBall.hpp"
+#include "DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp"
 #include "World/CPlayerCameraBob.hpp"
 
 namespace urde
@@ -36,6 +42,9 @@ void CTweaks::RegisterTweaks()
     const SObjectTag* tag;
 
     /* Particle */
+    tag = factory.GetResourceIdByName("Particle");
+    strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag));
+    g_tweakParticle = new DataSpec::DNAMP1::CTweakParticle(*strm);
 
     /* Player */
     tag = factory.GetResourceIdByName("Player");
@@ -48,10 +57,16 @@ void CTweaks::RegisterTweaks()
     CPlayerCameraBob::ReadTweaks(*strm);
 
     /* Ball */
+    tag = factory.GetResourceIdByName("Ball");
+    strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag));
+    g_tweakBall = new DataSpec::DNAMP1::CTweakBall(*strm);
 
     /* PlayerGun */
 
     /* Targeting */
+    tag = factory.GetResourceIdByName("Targeting");
+    strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag));
+    g_tweakTargeting = new DataSpec::DNAMP1::CTweakTargeting(*strm);
 
     /* Game */
     tag = factory.GetResourceIdByName("Game");
@@ -59,14 +74,31 @@ void CTweaks::RegisterTweaks()
     g_tweakGame = new DataSpec::DNAMP1::CTweakGame(*strm);
 
     /* GuiColors */
+    tag = factory.GetResourceIdByName("GuiColors");
+    strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag));
+    g_tweakGuiColors = new DataSpec::DNAMP1::CTweakGuiColors(*strm);
 
     /* AutoMapper */
+    tag = factory.GetResourceIdByName("AutoMapper");
+    strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag));
+    g_tweakAutoMapper = new DataSpec::DNAMP1::CTweakAutoMapper(*strm);
 
     /* Gui */
+    tag = factory.GetResourceIdByName("Gui");
+    strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag));
+    g_tweakGui = new DataSpec::DNAMP1::CTweakGui(*strm);
 
     /* PlayerControls */
+    tag = factory.GetResourceIdByName("PlayerControls");
+    strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag));
+    g_tweakPlayerControl = new DataSpec::DNAMP1::CTweakPlayerControl(*strm);
 
     /* PlayerControls2 */
+    tag = factory.GetResourceIdByName("PlayerControls2");
+    strm.emplace(factory.LoadResourceSync(*tag).release(), factory.ResourceSize(*tag));
+    g_tweakPlayerControlAlt = new DataSpec::DNAMP1::CTweakPlayerControl(*strm);
+
+    g_currentPlayerControl = g_tweakPlayerControl;
 
     /* SlideShow */
     tag = factory.GetResourceIdByName("SlideShow");
diff --git a/Runtime/MP1/Tweaks/CTweakAutoMapper.cpp b/Runtime/MP1/Tweaks/CTweakAutoMapper.cpp
deleted file mode 100644
index 9ed31f645..000000000
--- a/Runtime/MP1/Tweaks/CTweakAutoMapper.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include "CTweakAutoMapper.hpp"
-namespace urde
-{
-namespace MP1
-{
-CTweakAutoMapper::CTweakAutoMapper(CInputStream& in)
-{
-    x4_24_ = in.readBool();
-    x4_25_ = in.readBool();
-    x4_26_ = in.readBool();
-    x8_ = in.readFloatBig();
-    xc_ = in.readFloatBig();
-    x10_ = in.readFloatBig();
-    x14_ = in.readFloatBig();
-    x18_ = in.readFloatBig();
-    x1c_ = in.readFloatBig();
-    x20_ = in.readFloatBig();
-    x24_.readRGBABig(in);
-    x28_ = in.readFloatBig();
-    x2c_ = in.readFloatBig();
-    x30_ = in.readFloatBig();
-    x34_ = in.readFloatBig();
-    x38_.readRGBABig(in);
-    x3c_.readRGBABig(in);
-    x40_.readRGBABig(in);
-    x44_.readRGBABig(in);
-    x48_.readRGBABig(in);
-    x4c_.readRGBABig(in);
-    x50_.readRGBABig(in);
-    x54_ = in.readFloatBig();
-    x58_ = in.readFloatBig();
-    x5c_ = in.readFloatBig();
-    x64_ = in.readFloatBig();
-    x68_ = in.readFloatBig();
-    x6c_ = in.readFloatBig();
-    x70_ = in.readFloatBig();
-    x74_ = in.readFloatBig();
-    x78_ = in.readFloatBig();
-    x7c_.readRGBABig(in);
-    x80_.readRGBABig(in);
-    x84_ = in.readFloatBig();
-    x88_ = in.readFloatBig();
-    x8c_ = in.readFloatBig();
-    x90_ = in.readFloatBig();
-    x94_ = in.readFloatBig();
-    x98_ = in.readFloatBig();
-    x9c_ = in.readFloatBig();
-    xa0_ = in.readFloatBig();
-    /* Originally 4 separate floats */
-    xa4_doorCenter.readBig(in);
-    xb0_ = in.readFloatBig();
-    xb4_ = in.readFloatBig();
-    xb8_ = in.readFloatBig();
-    xbc_ = in.readFloatBig();
-    xc0_ = in.readFloatBig();
-    xc4_ = in.readFloatBig();
-    xc8_ = in.readFloatBig();
-    xcc_ = in.readBool();
-    xd0_ = in.readFloatBig();
-    xd4_ = in.readFloatBig();
-    xd8_ = in.readFloatBig();
-    xdc_ = in.readFloatBig();
-    xe0_ = in.readFloatBig();
-    xe4_ = in.readFloatBig();
-    xe8_ = in.readFloatBig();
-    xec_ = in.readFloatBig();
-    xf0_.readRGBABig(in);
-    xf4_.readRGBABig(in);
-    xf8_.readRGBABig(in);
-    xfc_.readRGBABig(in);
-    x100_doorColorCount = in.readUint32Big();
-    for (u32 i = 0 ; i<x100_doorColorCount ; ++i)
-    {
-        x104_doorColors.emplace_back();
-        x104_doorColors.back().readRGBABig(in);
-    }
-    x118_doorBorderColor.readRGBABig(in);
-    x11c_openDoorColor.readRGBABig(in);
-}
-}
-}
diff --git a/Runtime/MP1/Tweaks/CTweakAutoMapper.hpp b/Runtime/MP1/Tweaks/CTweakAutoMapper.hpp
deleted file mode 100644
index c0b53081c..000000000
--- a/Runtime/MP1/Tweaks/CTweakAutoMapper.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#ifndef __URDE_MP1_CTWEAKAUTOMAPPER_HPP__
-#define __URDE_MP1_CTWEAKAUTOMAPPER_HPP__
-
-#include "RetroTypes.hpp"
-#include "AutoMapper/ITweakAutoMapper.hpp"
-#include "zeus/CColor.hpp"
-
-namespace urde
-{
-namespace MP1
-{
-class CTweakAutoMapper : ITweakAutoMapper
-{
-private:
-    union
-    {
-        struct
-        {
-            bool x4_24_ : 1;
-            bool x4_25_ : 1;
-            bool x4_26_ : 1;
-        };
-    };
-    float x8_;
-    float xc_;
-    float x10_;
-    float x14_;
-    float x18_;
-    float x1c_;
-    float x20_;
-    zeus::CColor x24_;
-    float x28_;
-    float x2c_;
-    float x30_;
-    float x34_;
-    zeus::CColor x38_;
-    zeus::CColor x3c_;
-    zeus::CColor x40_;
-    zeus::CColor x44_;
-    zeus::CColor x48_;
-    zeus::CColor x4c_;
-    zeus::CColor x50_;
-    float x54_;
-    float x58_;
-    float x5c_;
-    float x60_ = 0.4f;
-    float x64_;
-    float x68_;
-    float x6c_;
-    float x70_;
-    float x74_;
-    float x78_;
-    zeus::CColor x7c_;
-    zeus::CColor x80_;
-    float x84_;
-    float x88_;
-    float x8c_;
-    float x90_;
-    float x94_;
-    float x98_;
-    float x9c_;
-    float xa0_;
-    /* Originally 4 separate floats */
-    zeus::CVector3f xa4_doorCenter;
-    float xb0_;
-    float xb4_;
-    float xb8_;
-    float xbc_;
-    float xc0_;
-    float xc4_;
-    float xc8_;
-    bool xcc_;
-    float xd0_;
-    float xd4_;
-    float xd8_;
-    float xdc_;
-    float xe0_;
-    float xe4_;
-    float xe8_;
-    float xec_;
-    zeus::CColor xf0_;
-    zeus::CColor xf4_;
-    zeus::CColor xf8_;
-    zeus::CColor xfc_;
-    u32 x100_doorColorCount;
-    std::vector<zeus::CColor> x104_doorColors;
-    zeus::CColor x118_doorBorderColor;
-    zeus::CColor x11c_openDoorColor;
-public:
-    CTweakAutoMapper(CInputStream&);
-    const zeus::CVector3f& GetDoorCenter() const { return xa4_doorCenter; }
-};
-}
-}
-#endif // __URDE_MP1_CTWEAKAUTOMAPPER_HPP__
diff --git a/Runtime/MP1/Tweaks/CTweakGui.cpp b/Runtime/MP1/Tweaks/CTweakGui.cpp
deleted file mode 100644
index f22916bea..000000000
--- a/Runtime/MP1/Tweaks/CTweakGui.cpp
+++ /dev/null
@@ -1,215 +0,0 @@
-#include "CTweakGui.hpp"
-
-namespace urde
-{
-u32 ReadUnknownValx27c(CInputStream& in)
-{
-    u32 tmp = in.readUint32Big();
-
-    if (tmp == 1)
-        return 2;
-    else if (tmp == 2)
-        return 4;
-    else if (tmp == 3)
-        return 5;
-
-    return 0;
-}
-std::vector<float> ReadScanSpeeds(CInputStream& in)
-{
-    u32 count = in.readUint32Big();
-    std::vector<float> ret;
-    ret.reserve(count);
-    for (u32 i = 0 ; i<count ; ++i)
-        ret.push_back(in.readFloatBig());
-    return ret;
-}
-
-CTweakGui::CTweakGui(CInputStream& in)
-    : x4_(in.readBool()),
-      x8_(in.readFloatBig()),
-      xc_(in.readFloatBig()),
-      x10_(in.readFloatBig()),
-      x14_(in.readFloatBig()),
-      x18_(in.readFloatBig()),
-      x1c_(in.readFloatBig()),
-      x20_(in.readFloatBig()),
-      x24_(in.readFloatBig()),
-      x28_(in.readFloatBig()),
-      x30_(in.readFloatBig()),
-      x34_(in.readFloatBig()),
-      x38_(in.readFloatBig()),
-      x3c_(in.readFloatBig()),
-      x40_(in.readBool()),
-      x44_(in.readFloatBig()),
-      x48_(in.readFloatBig()),
-      x4c_(in.readFloatBig()),
-      x50_(in.readFloatBig()),
-      x54_(in.readFloatBig()),
-      x58_(in.readFloatBig()),
-      x5c_(in.readFloatBig()),
-      x60_(in.readFloatBig()),
-      x64_(in.readVec3fBig()),
-      x70_(in.readVec3fBig()),
-      x7c_(in.readFloatBig()),
-      x80_(in.readFloatBig()),
-      x84_(in.readFloatBig()),
-      x88_(in.readFloatBig()),
-      x8c_(in.readFloatBig()),
-      x90_(in.readFloatBig()),
-      x94_(in.readFloatBig()),
-      x98_(in.readFloatBig()),
-      x9c_(in.readFloatBig()),
-      xa0_(in.readFloatBig()),
-      xa4_(in.readFloatBig()),
-      xa8_(in.readUint32Big()),
-      xac_(in.readUint32Big()),
-      xb0_(in.readUint32Big()),
-      xb4_(in.readFloatBig()),
-      xb8_(in.readFloatBig()),
-      xbc_(in.readFloatBig()),
-      xc0_(in.readFloatBig()),
-      xc4_(in.readFloatBig()),
-      xc8_(in.readFloatBig()),
-      xcc_(in.readFloatBig()),
-      xd0_(in.readFloatBig()),
-      xd4_(in.readUint32Big()),
-      xd8_(6.2831855f * (0.0027777778f * in.readFloatBig())),
-      xdc_(6.2831855f * (0.0027777778f * in.readFloatBig())),
-      xe0_(in.readFloatBig()),
-      xe4_(in.readFloatBig()),
-      xe8_(in.readFloatBig()),
-      xec_(in.readFloatBig()),
-      xf0_(in.readFloatBig()),
-      xf4_(in.readFloatBig()),
-      xf8_(in.readUint32Big()),
-      xfc_(in.readUint32Big()),
-      x100_(in.readUint32Big()),
-      x104_(in.readUint32Big()),
-      x108_(in.readUint32Big()),
-      x10c_(in.readUint32Big()),
-      x110_(in.readFloatBig()),
-      x114_(in.readFloatBig()),
-      x11c_(in.readFloatBig()),
-      x120_(in.readFloatBig()),
-      x124_(in.readFloatBig()),
-      x128_(in.readFloatBig()),
-      x12c_(in.readFloatBig()),
-      x130_(in.readBool()),
-      x134_(in.readFloatBig()),
-      x138_(in.readFloatBig()),
-      x13c_(float(in.readUint32Big())),
-      x140_(float(in.readUint32Big())),
-      x144_(float(in.readUint32Big())),
-      x148_(float(in.readUint32Big())),
-      x14c_(float(in.readUint32Big())),
-      x150_(in.readString()),
-      x160_(in.readString()),
-      x170_(in.readString()),
-      x180_(in.readString()),
-      x190_(in.readString()),
-      x1a0_(in.readFloatBig()),
-      x1a4_(in.readFloatBig()),
-      x1a8_(in.readFloatBig()),
-      x1ac_(in.readFloatBig()),
-      x1b0_(in.readFloatBig()),
-      x1b4_(in.readFloatBig()),
-      x1b8_(in.readFloatBig()),
-      x1bc_(in.readFloatBig()),
-      x1c0_(in.readFloatBig()),
-      x1c4_(in.readFloatBig()),
-      x1c8_(in.readFloatBig()),
-      x1cc_(in.readBool()),
-      x1cd_(in.readBool()),
-      x1d0_(in.readFloatBig()),
-      x1d4_(in.readFloatBig()),
-      x1d8_(in.readFloatBig()),
-      x1dc_(in.readFloatBig()),
-      x1e0_(in.readFloatBig()),
-      x1e4_(in.readFloatBig()),
-      x1e8_(in.readFloatBig()),
-      x1ec_(in.readFloatBig()),
-      x1f0_(in.readFloatBig()),
-      x1f4_(in.readFloatBig()),
-      x1f8_(in.readFloatBig()),
-      x1fc_(in.readFloatBig()),
-      x200_(x1f4_ * 0.25f, x1f8_ * 0.25f, x1fc_ * 0.25f, 1.0f),
-      x20c_(in.readFloatBig()),
-      x210_(6.2831855f * (0.0027777778f * in.readFloatBig())),
-      x214_(in.readFloatBig()),
-      x218_(in.readFloatBig()),
-      x21c_(in.readFloatBig()),
-      x220_(in.readFloatBig()),
-      x224_(in.readFloatBig()),
-      x228_(x220_ + x224_),
-      x22c_(in.readFloatBig()),
-      x230_(in.readFloatBig()),
-      x234_(in.readFloatBig()),
-      x238_(in.readFloatBig()),
-      x23c_(in.readFloatBig()),
-      x240_(in.readFloatBig()),
-      x244_(in.readFloatBig()),
-      x248_(in.readFloatBig()),
-      x24c_(in.readFloatBig()),
-      x250_(in.readFloatBig()),
-      x254_(in.readFloatBig()),
-      x258_(in.readFloatBig()),
-      x25c_(in.readFloatBig()),
-      x260_(in.readFloatBig()),
-      x264_(in.readFloatBig()),
-      x268_(in.readFloatBig()),
-      x26c_(in.readFloatBig()),
-      x270_(in.readFloatBig()),
-      x274_(in.readBool()),
-      x278_(in.readFloatBig()),
-      x27c_(ReadUnknownValx27c(in)),
-      x280_(in.readFloatBig()),
-      x284_(in.readFloatBig()),
-      x288_(in.readVec4fBig()),
-      x28c_(in.readFloatBig()),
-      x290_(in.readVec4fBig()),
-      x294_(in.readVec4fBig()),
-      x298_(in.readVec4fBig()),
-      x29c_(in.readVec4fBig()),
-      x2a0_(in.readVec4fBig()),
-      x2a4_(in.readVec4fBig()),
-      x2a8_(in.readVec4fBig()),
-      x2ac_(in.readVec4fBig()),
-      x2b0_(in.readVec4fBig()),
-      x2b4_(in.readVec4fBig()),
-      x2b8_(in.readFloatBig()),
-      x2bc_(in.readFloatBig()),
-      x2c0_(in.readFloatBig()),
-      x2c4_scanSpeeds(ReadScanSpeeds(in)),
-      x2d0_(in.readString()),
-      x2e0_(in.readString()),
-      x2f0_(in.readString()),
-      x300_(in.readVec4fBig()),
-      x304_(in.readVec4fBig()),
-      x308_(in.readFloatBig()),
-      x30c_(in.readFloatBig()),
-      x310_(in.readFloatBig()),
-      x314_(in.readString()),
-      x324_(in.readString()),
-      x334_(in.readString()),
-      x344_(in.readVec4fBig()),
-      x348_(in.readVec4fBig()),
-      x34c_(in.readVec4fBig()),
-      x350_(in.readVec4fBig()),
-      x354_(in.readVec4fBig()),
-      x358_(in.readVec4fBig()),
-      x35c_(in.readFloatBig()),
-      x360_(in.readFloatBig()),
-      x364_(in.readFloatBig())
-{
-    x84_ *= 2.0f;
-}
-
-float CTweakGui::GetScanSpeed(s32 idx) const
-{
-    if (idx < 0 || idx >= x2c4_scanSpeeds.size())
-        return 0.f;
-    return x2c4_scanSpeeds[idx];
-}
-
-}
diff --git a/Runtime/MP1/Tweaks/CTweakGui.hpp b/Runtime/MP1/Tweaks/CTweakGui.hpp
deleted file mode 100644
index a2c65fb36..000000000
--- a/Runtime/MP1/Tweaks/CTweakGui.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-#ifndef __URDE_MP1_CTWEAKGUI_HPP__
-#define __URDE_MP1_CTWEAKGUI_HPP__
-
-#include "GuiSys/ITweakGui.hpp"
-#include "zeus/CVector3f.hpp"
-#include "zeus/CColor.hpp"
-
-namespace urde
-{
-class CTweakGui : public ITweakGui
-{
-    bool x4_;
-    float x8_;
-    float xc_;
-    float x10_;
-    float x14_;
-    float x18_;
-    float x1c_;
-    float x20_;
-    float x24_;
-    float x28_;
-    u32 x2c_ = 0;
-    float x30_;
-    float x34_;
-    float x38_;
-    float x3c_;
-    bool x40_;
-    float x44_;
-    float x48_;
-    float x4c_;
-    float x50_;
-    float x54_;
-    float x58_;
-    float x5c_;
-    float x60_;
-    zeus::CVector3f x64_;
-    zeus::CVector3f x70_;
-    float x7c_;
-    float x80_;
-    float x84_;
-    float x88_;
-    float x8c_;
-    float x90_;
-    float x94_;
-    float x98_;
-    float x9c_;
-    float xa0_;
-    float xa4_;
-    u32 xa8_;
-    u32 xac_;
-    u32 xb0_;
-    float xb4_;
-    float xb8_;
-    float xbc_;
-    float xc0_;
-    float xc4_;
-    float xc8_;
-    float xcc_;
-    float xd0_;
-    u32 xd4_;
-    float xd8_;
-    float xdc_;
-    float xe0_;
-    float xe4_;
-    float xe8_;
-    float xec_;
-    float xf0_;
-    float xf4_;
-    u32 xf8_;
-    u32 xfc_;
-    u32 x100_;
-    u32 x104_;
-    u32 x108_;
-    u32 x10c_;
-    float x110_;
-    float x114_;
-    float x118_;
-    float x11c_;
-    float x120_;
-    float x124_;
-    float x128_;
-    float x12c_;
-    bool x130_;
-    float x134_;
-    float x138_;
-    float x13c_;
-    float x140_;
-    float x144_;
-    float x148_;
-    float x14c_;
-    std::string x150_;
-    std::string x160_;
-    std::string x170_;
-    std::string x180_;
-    std::string x190_;
-    float x1a0_;
-    float x1a4_;
-    float x1a8_;
-    float x1ac_;
-    float x1b0_;
-    float x1b4_;
-    float x1b8_;
-    float x1bc_;
-    float x1c0_;
-    float x1c4_;
-    float x1c8_;
-    bool x1cc_;
-    bool x1cd_;
-    float x1d0_;
-    float x1d4_;
-    float x1d8_;
-    float x1dc_;
-    float x1e0_;
-    float x1e4_;
-    float x1e8_;
-    float x1ec_;
-    float x1f0_;
-    float x1f4_;
-    float x1f8_;
-    float x1fc_;
-    zeus::CColor x200_;
-    float x204_ = 0.0014f;
-    float x208_ = 0.0000525f;
-    float x20c_;
-    float x210_;
-    float x214_;
-    float x218_;
-    float x21c_;
-    float x220_;
-    float x224_;
-    float x228_;
-    float x22c_;
-    float x230_;
-    float x234_;
-    float x238_;
-    float x23c_;
-    float x240_;
-    float x244_;
-    float x248_;
-    float x24c_;
-    float x250_;
-    float x254_;
-    float x258_;
-    float x25c_;
-    float x260_;
-    float x264_;
-    float x268_;
-    float x26c_;
-    float x270_;
-    bool x274_;
-    bool x275_ = true;
-    float x278_;
-    u32 x27c_;
-    float x280_;
-    float x284_;
-    zeus::CColor x288_;
-    float x28c_;
-    zeus::CColor x290_;
-    zeus::CColor x294_;
-    zeus::CColor x298_;
-    zeus::CColor x29c_;
-    zeus::CColor x2a0_;
-    zeus::CColor x2a4_;
-    zeus::CColor x2a8_;
-    zeus::CColor x2ac_;
-    zeus::CColor x2b0_;
-    zeus::CColor x2b4_;
-    float x2b8_;
-    float x2bc_;
-    float x2c0_;
-    std::vector<float> x2c4_scanSpeeds;
-    std::string x2d0_;
-    std::string x2e0_;
-    std::string x2f0_;
-    zeus::CColor x300_;
-    zeus::CColor x304_;
-    float x308_;
-    float x30c_;
-    float x310_;
-    std::string x314_;
-    std::string x324_;
-    std::string x334_;
-    zeus::CColor x344_;
-    zeus::CColor x348_;
-    zeus::CColor x34c_;
-    zeus::CColor x350_;
-    zeus::CColor x354_;
-    zeus::CColor x358_;
-    float x35c_;
-    float x360_;
-    float x364_;
-public:
-    CTweakGui(CInputStream&);
-
-    float GetScanSpeed(s32) const;
-};
-}
-#endif // __URDE_MP1_CTWEAKGUI_HPP__
diff --git a/Runtime/MP1/Tweaks/CTweakPlayer.cpp b/Runtime/MP1/Tweaks/CTweakPlayer.cpp
deleted file mode 100644
index 147db90fd..000000000
--- a/Runtime/MP1/Tweaks/CTweakPlayer.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-#include "CTweakPlayer.hpp"
-#include "zeus/Math.hpp"
-
-namespace urde
-{
-namespace MP1
-{
-CTweakPlayer::CTweakPlayer(urde::CInputStream& in)
-{
-    for (u32 i = 0 ; i<8 ; ++i)
-        x4_[i] = in.readFloatBig();
-    for (u32 i = 0 ; i<8 ; ++i)
-        x24_[i] = in.readFloatBig();
-    for (u32 i = 0 ; i<8 ; ++i)
-        x44_[i] = in.readFloatBig();
-    for (u32 i = 0 ; i<8 ; ++i)
-        x64_[i] = in.readFloatBig();
-    for (u32 i = 0 ; i<8 ; ++i)
-        x84_[i] = in.readFloatBig();
-    for (u32 i = 0 ; i<8 ; ++i)
-        xa4_[i] = in.readFloatBig();
-    xc4_ = in.readFloatBig();
-    xc8_ = in.readFloatBig();
-    xcc_ = in.readFloatBig();
-    xd0_ = in.readFloatBig();
-    xd4_ = in.readFloatBig();
-    xd8_ = in.readFloatBig();
-    xdc_ = in.readFloatBig();
-    xe0_ = in.readFloatBig();
-    xe4_ = in.readFloatBig();
-    xe8_ = in.readFloatBig();
-    xec_ = in.readFloatBig();
-    xf0_ = in.readFloatBig();
-    xf4_ = in.readFloatBig();
-    xf8_ = in.readFloatBig();
-    xfc_ = in.readFloatBig();
-    x100_ = in.readFloatBig();
-    x104_ = in.readFloatBig();
-    x108_ = in.readFloatBig();
-    x10c_ = in.readFloatBig();
-    x11c_ = in.readFloatBig();
-    x120_ = in.readFloatBig();
-    x124_ = in.readFloatBig();
-    x128_ = in.readFloatBig();
-    x12c_ = in.readFloatBig();
-    x130_ = zeus::degToRad(in.readFloatBig());
-    x134_ = zeus::degToRad(in.readFloatBig());
-    x138_ = zeus::degToRad(in.readFloatBig());
-    x13c_ = zeus::degToRad(in.readFloatBig());
-    x140_ = zeus::degToRad(in.readFloatBig());
-    x144_ = zeus::degToRad(in.readFloatBig());
-    x148_ = in.readFloatBig();
-    x14c_ = in.readFloatBig();
-    x150_ = in.readFloatBig();
-    x228_24_ = in.readBool();
-    x228_25_ = in.readBool();
-    x228_26_ = in.readBool();
-    x228_27_ = in.readBool();
-    x228_28_ = in.readBool();
-    x228_29_ = in.readBool();
-    x228_30_ = in.readBool();
-    x228_31_ = in.readBool();
-    x229_24_ = in.readBool();
-    x229_25_ = in.readBool();
-    x229_26_ = in.readBool();
-    x229_27_ = in.readBool();
-    x229_28_ = in.readBool();
-    x229_29_ = in.readBool();
-    x229_30_ = in.readBool();
-    x229_31_ = in.readBool();
-    x22a_24_ = in.readBool();
-    x22a_25_ = in.readBool();
-    x22a_26_ = in.readBool();
-    x22a_27_ = in.readBool();
-    x22a_28_ = in.readBool();
-    x22c_ = in.readFloatBig();
-    x230_ = in.readFloatBig();
-    x234_ = in.readFloatBig();
-    x238_ = zeus::degToRad(in.readFloatBig());
-    x23c_ = zeus::degToRad(in.readFloatBig());
-    x240_ = zeus::degToRad(in.readFloatBig());
-    x244_ = zeus::degToRad(in.readFloatBig());
-    x248_ = zeus::degToRad(in.readFloatBig());
-    x24c_ = in.readFloatBig();
-    x250_ = zeus::degToRad(in.readFloatBig());
-    x254_ = in.readFloatBig();
-    x258_ = in.readFloatBig();
-    x25c_ = in.readFloatBig();
-    x260_ = in.readFloatBig();
-    x264_ = zeus::degToRad(in.readFloatBig());
-    for (u32 i = 0 ; i<3 ; ++i)
-    {
-        x158_[i] = in.readFloatBig();
-        x164_[i] = in.readFloatBig();
-        x170_[i] = in.readFloatBig();
-    }
-    x17c_ = zeus::degToRad(in.readFloatBig());
-    x180_ = in.readFloatBig();
-    x184_ = zeus::degToRad(in.readFloatBig());
-    x188_ = zeus::degToRad(in.readFloatBig());
-    x18c_ = zeus::degToRad(in.readFloatBig());
-    x190_ = zeus::degToRad(in.readFloatBig());
-    x194_ = zeus::degToRad(in.readFloatBig());
-    x198_ = zeus::degToRad(in.readFloatBig());
-    x19c_ = in.readFloatBig();
-    x1a0_ = in.readFloatBig();
-    x1a4_ = in.readFloatBig();
-    for (u32 i = 0 ; i<2 ; ++i)
-    {
-        x1a8_[i] = in.readUint32Big();
-        x1b0_[i] = in.readUint32Big();
-        x1b8_[i] = in.readUint32Big();
-        x1c0_[i] = in.readUint32Big();
-        x1c8_[i] = in.readUint32Big();
-    }
-
-    x1d8_ = in.readFloatBig();
-    x1dc_ = in.readFloatBig();
-    x1e0_ = in.readFloatBig();
-    x1e4_ = in.readFloatBig();
-    x1e8_ = in.readFloatBig();
-    x1ec_ = in.readFloatBig();
-    x1f0_ = zeus::degToRad(in.readFloatBig());
-    x1f4_ = zeus::degToRad(in.readFloatBig());
-    x1f8_ = in.readFloatBig();
-    x1fc_ = in.readFloatBig();
-    x200_24_ = in.readBool();
-    x200_25_ = in.readBool();
-    x204_ = in.readFloatBig();
-    x208_ = in.readFloatBig();
-    x20c_ = in.readFloatBig();
-    x210_ = in.readFloatBig();
-    x214_ = in.readFloatBig();
-    x218_ = in.readFloatBig();
-    x21c_24_ = in.readBool();
-    x21c_25_ = in.readBool();
-    x220_  = in.readFloatBig();
-    x224_ = in.readFloatBig();
-    x2a0_ = in.readFloatBig();
-    x2a4_ = in.readFloatBig();
-    x2a8_ = in.readFloatBig();
-    x2ac_ = in.readFloatBig();
-    x2b0_ = zeus::degToRad(in.readFloatBig());
-    x2b4_ = in.readFloatBig();
-    x2b8_ = in.readFloatBig();
-    x2bc_ = in.readFloatBig();
-    x2c0_ = zeus::degToRad(in.readFloatBig());
-    x2c4_ = in.readFloatBig();
-    x2c8_ = in.readFloatBig();
-    x2cc_ = in.readFloatBig();
-    x2d0_ = in.readUint32Big();
-    x2d4_ = in.readBool();
-    x2d5_ = in.readBool();
-    x2d8_ = in.readFloatBig();
-    x2dc_ = in.readFloatBig();
-    x2e0_ = in.readFloatBig();
-    x2e4_ = in.readFloatBig();
-    x26c_ = in.readFloatBig();
-    x270_ = in.readFloatBig();
-    x274_ = in.readFloatBig();
-    x278_ = in.readFloatBig();
-    x27c_ = in.readFloatBig();
-    x280_ = zeus::degToRad(in.readFloatBig());
-    x284_ = zeus::degToRad(in.readFloatBig());
-    x288_ = in.readFloatBig();
-    x28c_ = in.readFloatBig();
-    x290_ = zeus::degToRad(in.readFloatBig());
-    x294_ = in.readFloatBig();
-    x298_ = in.readFloatBig();
-    x29c_ = zeus::degToRad(in.readFloatBig());
-    x2e8_ = in.readFloatBig();
-    x2ec_ = in.readFloatBig();
-    x2f0_ = in.readFloatBig();
-    x2f4_ = in.readBool();
-    x2f8_ = in.readFloatBig();
-    x2fc_ = in.readFloatBig();
-    x300_ = in.readFloatBig();
-    x304_ = in.readFloatBig();
-    x308_ = in.readFloatBig();
-}
-}
-}
diff --git a/Runtime/MP1/Tweaks/CTweakPlayer.hpp b/Runtime/MP1/Tweaks/CTweakPlayer.hpp
deleted file mode 100644
index 10dba65c2..000000000
--- a/Runtime/MP1/Tweaks/CTweakPlayer.hpp
+++ /dev/null
@@ -1,202 +0,0 @@
-#ifndef __URDE_MP1_CTWEAKPLAYER_HPP__
-#define __URDE_MP1_CTWEAKPLAYER_HPP__
-
-#include "RetroTypes.hpp"
-#include "ITweak.hpp"
-namespace urde
-{
-namespace MP1
-{
-class CTweakPlayer : public ITweak
-{
-    float x4_[8];
-    float x24_[8];
-    float x44_[8];
-    float x64_[8];
-    float x84_[8];
-    float xa4_[8];
-    float xc4_;
-    float xc8_;
-    float xcc_;
-    float xd0_;
-    float xd4_;
-    float xd8_;
-    float xdc_;
-    float xe0_;
-    float xe4_;
-    float xe8_;
-    float xec_;
-    float xf0_;
-    float xf4_;
-    float xf8_;
-    float xfc_;
-    float x100_;
-    float x104_;
-    float x108_;
-    float x10c_;
-    float x110_;
-    float x114_;
-    float x118_;
-    float x11c_;
-    float x120_;
-    float x124_;
-    float x128_;
-    float x12c_;
-    float x130_;
-    float x134_;
-    float x138_;
-    float x13c_;
-    float x140_;
-    float x144_;
-    float x148_;
-    float x14c_;
-    float x150_;
-    float x154_;
-    float x158_[3];
-    float x164_[3];
-    float x170_[3];
-    float x17c_;
-    float x180_;
-    float x184_;
-    float x188_;
-    float x18c_;
-    float x190_;
-    float x194_;
-    float x198_;
-    float x19c_;
-    float x1a0_;
-    float x1a4_;
-    u32 x1a8_[2];
-    u32 x1b0_[2];
-    u32 x1b8_[2];
-    u32 x1c0_[2];
-    u32 x1c8_[2];
-    u32 x1d0_[2];
-    float x1d8_;
-    float x1dc_;
-    float x1e0_;
-    float x1e4_;
-    float x1e8_;
-    float x1ec_;
-    float x1f0_;
-    float x1f4_;
-    float x1f8_;
-    float x1fc_;
-    union
-    {
-        struct
-        {
-            bool x200_24_ : 1;
-            bool x200_25_ : 1;
-        };
-        u8 _dummy1 = 0;
-    };
-    float x204_;
-    float x208_;
-    float x20c_;
-    float x210_;
-    float x214_;
-    float x218_;
-    union
-    {
-        struct
-        {
-            bool x21c_24_ : 1;
-            bool x21c_25_ : 1;
-        };
-        u8 _dummy2 = 0;
-    };
-    float x220_;
-    float x224_;
-    union
-    {
-        struct
-        {
-            bool x228_24_ : 1;
-            bool x228_25_ : 1;
-            bool x228_26_ : 1;
-            bool x228_27_ : 1;
-            bool x228_28_ : 1;
-            bool x228_29_ : 1;
-            bool x228_30_ : 1;
-            bool x228_31_ : 1;
-            bool x229_24_ : 1;
-            bool x229_25_ : 1;
-            bool x229_26_ : 1;
-            bool x229_27_ : 1;
-            bool x229_28_ : 1;
-            bool x229_29_ : 1;
-            bool x229_30_ : 1;
-            bool x229_31_ : 1;
-            bool x22a_24_ : 1;
-            bool x22a_25_ : 1;
-            bool x22a_26_ : 1;
-            bool x22a_27_ : 1;
-            bool x22a_28_ : 1;
-        };
-        u32 _dummy3 = 0;
-    };
-    float x22c_;
-    float x230_;
-    float x234_;
-    float x238_;
-    float x23c_;
-    float x240_;
-    float x244_;
-    float x248_;
-    float x24c_;
-    float x250_;
-    float x254_;
-    float x258_;
-    float x25c_;
-    float x260_;
-    float x264_;
-    float x268_;
-    float x26c_;
-    float x270_;
-    float x274_;
-    float x278_;
-    float x27c_;
-    float x280_;
-    float x284_;
-    float x288_;
-    float x28c_;
-    float x290_;
-    float x294_;
-    float x298_;
-    float x29c_;
-    float x2a0_;
-    float x2a4_;
-    float x2a8_;
-    float x2ac_;
-    float x2b0_;
-    float x2b4_;
-    float x2b8_;
-    float x2bc_;
-    float x2c0_;
-    float x2c4_;
-    float x2c8_;
-    float x2cc_;
-    u32 x2d0_;
-    bool x2d4_;
-    bool x2d5_;
-    float x2d8_;
-    float x2dc_;
-    float x2e0_;
-    float x2e4_;
-    float x2e8_;
-    float x2ec_;
-    float x2f0_;
-    bool x2f4_;
-    float x2f8_;
-    u32 x2fc_;
-    float x300_;
-    float x304_;
-    float x308_;
-public:
-    CTweakPlayer(CInputStream&);
-    virtual ~CTweakPlayer() {}
-};
-}
-}
-#endif // __URDE_MP1_CTWEAKPLAYER_HPP__