From 7857d344a213c7cfb311ee83462b9f988345caa8 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Tue, 2 Aug 2022 20:35:06 +0200
Subject: [PATCH 01/11] WIP: Support for Duke Nukem Forever #49

---
 src/Core/Classes/Props/UProperty.cs | 30 ++++++++++++++++++++++++++
 src/Core/Classes/UStruct.cs         | 33 +++++++++++++++++++++++++++++
 src/Eliot.UELib.csproj              |  4 ++--
 src/UnrealPackage.cs                |  8 +++++++
 4 files changed, 73 insertions(+), 2 deletions(-)

diff --git a/src/Core/Classes/Props/UProperty.cs b/src/Core/Classes/Props/UProperty.cs
index b99923f..e535f8a 100644
--- a/src/Core/Classes/Props/UProperty.cs
+++ b/src/Core/Classes/Props/UProperty.cs
@@ -85,6 +85,16 @@ protected override void Deserialize()
                 uint unknown = _Buffer.ReadUInt32();
                 Record("Unknown:AA2", unknown);
             }
+#endif
+#if DNF
+            if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF)
+            {
+                ArrayDim = _Buffer.ReadUInt16();
+                Record("ArrayDim", ArrayDim);
+                Debug.Assert(ArrayDim <= 2048, "Bad array dim");
+                // No serialized element size?
+                goto skipInfo;
+            }
 #endif
             int info = _Buffer.ReadInt32();
             ArrayDim = (ushort)(info & 0x0000FFFFU);
@@ -161,6 +171,26 @@ protected override void Deserialize()
                 var vengeanceEditDisplay = _Buffer.ReadNameReference();
                 Record(nameof(vengeanceEditDisplay), vengeanceEditDisplay);
             }
+#endif
+#if DNF
+            if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF)
+            {
+                if ((PropertyFlags & 0x800000) != 0)
+                {
+                    EditorDataText = _Buffer.ReadText();
+                    Record(nameof(EditorDataText), EditorDataText);
+                }
+
+                // Same flag as EditorData, but this may merely be a coincidence, see above
+                if (_Buffer.Version >= 118 && (PropertyFlags & 0x2000000) != 0)
+                {
+                    // NU_NAME???
+                    var dnfNuPropertyName = _Buffer.ReadNameReference();
+                    Record(nameof(dnfNuPropertyName), dnfNuPropertyName);
+                }
+
+                return;
+            }
 #endif
             // Appears to be a UE2.5 feature, it is not present in UE2 builds with no custom LicenseeVersion
             // Albeit DeusEx indicates otherwise?
diff --git a/src/Core/Classes/UStruct.cs b/src/Core/Classes/UStruct.cs
index 7353f94..d95ff63 100644
--- a/src/Core/Classes/UStruct.cs
+++ b/src/Core/Classes/UStruct.cs
@@ -99,7 +99,33 @@ protected override void Deserialize()
                 FriendlyName = _Buffer.ReadNameReference();
                 Record(nameof(FriendlyName), FriendlyName);
             }
+#if DNF
+            if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF)
+            {
+                if (_Buffer.LicenseeVersion >= 17)
+                {
+                    // Back-ported CppText
+                    CppText = _Buffer.ReadObject<UTextBuffer>();
+                    Record(nameof(CppText), CppText);
+                    
+                    var dnfTextObj2 = _Buffer.ReadObject();
+                    Record(nameof(dnfTextObj2), dnfTextObj2);
+                    
+                    _Buffer.ReadArray(out UArray<UObject> dnfIncludeTexts);
+                    Record(nameof(dnfIncludeTexts), dnfIncludeTexts);
+                }
 
+                if (_Buffer.LicenseeVersion >= 2)
+                {
+                    // Bool?
+                    _Buffer.ReadByte();
+                    var dnfName = _Buffer.ReadNameReference();
+                    Record(nameof(dnfName), dnfName);
+                }
+                
+                goto lineData;
+            }
+#endif
             // Standard, but UT2004' derived games do not include this despite reporting version 128+
             if (Package.Version >= VCppText && _Buffer.UE4Version < 117
                 && !Package.IsConsoleCooked() &&
@@ -133,6 +159,7 @@ protected override void Deserialize()
                 Record(nameof(ProcessedText), ProcessedText);
             }
 #endif
+            lineData:
             if (!Package.IsConsoleCooked() &&
                 _Buffer.UE4Version < 117)
             {
@@ -203,6 +230,12 @@ protected override void Deserialize()
                     ByteCodeManager.Deserialize();
                 }
             }
+#if DNF
+            if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF)
+            {
+                //_Buffer.ReadByte();
+            }
+#endif
         }
 
         protected override bool CanDisposeBuffer()
diff --git a/src/Eliot.UELib.csproj b/src/Eliot.UELib.csproj
index 42fd785..90b57c6 100644
--- a/src/Eliot.UELib.csproj
+++ b/src/Eliot.UELib.csproj
@@ -43,7 +43,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;DECOMPILE BINARYMETADATA Forms UE1 UE2 UE3 UE4 VENGEANCE SWAT4 UNREAL2 INFINITYBLADE BORDERLANDS2 GOW2 DEBUG_TEST APB SPECIALFORCE2 XIII SINGULARITY THIEF_DS DEUSEX_IW BORDERLANDS MIRRORSEDGE BIOSHOCK HAWKEN UT DISHONORED REMEMBERME ALPHAPROTOCOL VANGUARD TERA MKKE TRANSFORMERS XCOM2 DD2 DCUO AA2 SPELLBORN BATMAN MOH ROCKETLEAGUE</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;DECOMPILE BINARYMETADATA Forms UE1 UE2 UE3 UE4 VENGEANCE SWAT4 UNREAL2 INFINITYBLADE BORDERLANDS2 GOW2 DEBUG_TEST APB SPECIALFORCE2 XIII SINGULARITY THIEF_DS DEUSEX_IW BORDERLANDS MIRRORSEDGE BIOSHOCK HAWKEN UT DISHONORED REMEMBERME ALPHAPROTOCOL VANGUARD TERA MKKE TRANSFORMERS XCOM2 DD2 DCUO AA2 SPELLBORN BATMAN MOH ROCKETLEAGUE DNF</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>0</WarningLevel>
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -257,7 +257,7 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties BuildVersion_BuildVersioningStyle="None.None.Increment.None" BuildVersion_UpdateFileVersion="True" BuildVersion_UpdateAssemblyVersion="True" />
+      <UserProperties BuildVersion_UpdateAssemblyVersion="True" BuildVersion_UpdateFileVersion="True" BuildVersion_BuildVersioningStyle="None.None.Increment.None" />
     </VisualStudio>
   </ProjectExtensions>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/src/UnrealPackage.cs b/src/UnrealPackage.cs
index c9c1128..c9d21f9 100644
--- a/src/UnrealPackage.cs
+++ b/src/UnrealPackage.cs
@@ -271,6 +271,14 @@ public enum BuildName
                 [Build(130, 143, 56u, 59u, BuildGeneration.Vengeance)]
                 BioShock,
 
+                /// <summary>
+                /// Duke Nukem Forever
+                ///
+                /// 156/036
+                /// </summary>
+                [Build(156, 36u, BuildGeneration.UE2)]
+                DNF,
+
                 /// <summary>
                 /// The Chronicles of Spellborn
                 /// 

From 2d3112540cb3c671343e6bdfad48cd0f12ef1823 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Thu, 4 Aug 2022 00:42:39 +0200
Subject: [PATCH 02/11] Mapped the entire bytecode set for DNF #49.

---
 src/ByteCodeDecompiler.cs        | 99 +++++++++++++++++++++++++++++++-
 src/Core/Tokens/CastTokens.cs    |  2 +-
 src/Core/Tokens/ContextTokens.cs | 39 +++++++------
 src/Core/Tokens/JumpTokens.cs    |  6 +-
 src/Eliot.UELib.csproj           |  4 +-
 src/UnrealTokens.cs              |  4 +-
 6 files changed, 129 insertions(+), 25 deletions(-)

diff --git a/src/ByteCodeDecompiler.cs b/src/ByteCodeDecompiler.cs
index 0032a1f..e4c2f2f 100644
--- a/src/ByteCodeDecompiler.cs
+++ b/src/ByteCodeDecompiler.cs
@@ -327,10 +327,102 @@ private void AlignObjectSize()
                 //{ (byte)ExprToken.OutVariable, (byte)ExprToken.LogFunction }
             };
 #endif
+#if DNF
+            private static readonly Dictionary<byte, byte> ByteCodeMap_BuildDnf = new Dictionary<byte, byte>
+            {
+                //{ (byte)ExprToken.LocalVariable, (byte)ExprToken.LocalVariable },
+                //{ (byte)ExprToken.InstanceVariable, (byte)ExprToken.InstanceVariable },
+                //{ (byte)ExprToken.DefaultVariable, (byte)ExprToken.DefaultVariable },
+                { 0x03, (byte)ExprToken.Unused },
+                //{ 0x04, (byte)ExprToken.Unused },
+                //{ 0x0C, (byte)ExprToken.LabelTable },
+                //{ 0x0D, (byte)ExprToken.Unused },
+                //{ 0x0E, (byte)ExprToken.Unused },
+                //{ 0x12, (byte)ExprToken.ClassContext },
+                //{ 0x13, (byte)ExprToken.MetaCast },
+                { 0x15, (byte)ExprToken.Unused },
+                //{ 0x16, (byte)ExprToken.EndFunctionParms },
+                //{ 0x18, (byte)ExprToken.Skip },
+                //{ 0x19, (byte)ExprToken.Context },
+                //{ 0x1B, (byte)ExprToken.VirtualFunction },
+                //{ 0x1C, (byte)ExprToken.FinalFunction },
+                { 0x2B, (byte)ExprToken.Unused },
+                //{ 0x2E, (byte)ExprToken.DynamicCast },
+                { 0x35, (byte)ExprToken.Unused },
+                //{ 0x36, (byte)ExprToken.StructMember },
+                { 0x37/*DynArrayLength*/, (byte)ExprToken.DebugInfo },
+                //{ 0x38, (byte)ExprToken.GlobalFunction },
+                { 0x39/*PrimitiveCast*/, (byte)ExprToken.Unused },
+                { 0x3A, (byte)ExprToken.Unused },
+                { 0x3B, (byte)ExprToken.Unused },
+                { 0x3C, (byte)ExprToken.Unused },
+                { 0x3D, (byte)ExprToken.Unused },
+                { 0x3E, (byte)ExprToken.Unused },
+                { 0x3F, (byte)ExprToken.Unused },
+                { 0x40, (byte)ExprToken.Unused },
+                { 0x41, (byte)ExprToken.Unused },
+                { 0x42, (byte)ExprToken.Unused },
+                { 0x43, (byte)ExprToken.Unused },
+                { 0x44, (byte)ExprToken.Unused },
+                { 0x45, (byte)ExprToken.Unused },
+                { 0x46, (byte)ExprToken.Unused },
+                { 0x47, (byte)ExprToken.Unused },
+                { 0x48, (byte)ExprToken.Unused },
+                { 0x49, (byte)ExprToken.Unused },
+                { 0x4A, (byte)ExprToken.Unused },
+                { 0x4B, (byte)ExprToken.Unused },
+                { 0x4C, (byte)ExprToken.Unused },
+                { 0x4D, (byte)ExprToken.Unused },
+                { 0x4E, (byte)ExprToken.Unused },
+                { 0x4F, (byte)ExprToken.Unused },
+                { 0x50, (byte)ExprToken.Unused },
+                { 0x51, (byte)ExprToken.Unused },
+                { 0x52, (byte)ExprToken.Unused },
+                { 0x53, (byte)ExprToken.Unused },
+                { 0x54, (byte)ExprToken.Unused },
+                { 0x55, (byte)ExprToken.Unused },
+                { 0x56, (byte)ExprToken.Unused },
+                { 0x57, (byte)ExprToken.Unused },
+                { 0x58, (byte)ExprToken.Unused },
+                { 0x59, (byte)ExprToken.Unused },
+                { 0x5A, (byte)ExprToken.DynArrayLength }, // keyword > expr
+                { 0x5B, (byte)ExprToken.DynArrayInsert }, // expr > expr
+                { 0x5C, (byte)ExprToken.DynArrayAdd }, // expr > expr
+                { 0x5D, (byte)ExprToken.DynArrayRemove }, // expr > expr
+                { 0x5E, (byte)ExprToken.DelegateFunction }, // object > name
+                { 0x5F, (byte)ExprToken.DelegateProperty }, // name
+                { 0x60, (byte)ExprToken.LetDelegate }, // expr > expr
+                { 0x61, (byte)ExprToken.InternalUnresolved }, // void (VectorConstZero)
+                { 0x62, (byte)ExprToken.InternalUnresolved }, // void (VectorConstUnitZ)
+                { 0x63, (byte)ExprToken.InternalUnresolved }, // void (RotConstZero)
+                { 0x64, (byte)ExprToken.InternalUnresolved }, // ushort (IntConstWord)
+                { 0x65, (byte)ExprToken.InternalUnresolved }, // byte > byte > byte (RotConstBytes)
+                { 0x66, (byte)ExprToken.InternalUnresolved }, // keyword > expr (DynArrayEmpty)
+                { 0x67, (byte)ExprToken.InternalUnresolved }, // void (Breakpoint)
+                { 0x68, (byte)ExprToken.Unused },
+                { 0x69, (byte)ExprToken.InternalUnresolved }, // int (RotConstPitch)
+                { 0x6A, (byte)ExprToken.InternalUnresolved }, // int (RotConstYaw)
+                { 0x6B, (byte)ExprToken.InternalUnresolved }, // int (RotConstRoll)
+                { 0x6C, (byte)ExprToken.InternalUnresolved }, // int (VectorX)
+                { 0x6D, (byte)ExprToken.InternalUnresolved }, // int (VectorY)
+                { 0x6E, (byte)ExprToken.InternalUnresolved }, // int (VectorZ)
+                { 0x6F, (byte)ExprToken.InternalUnresolved }, // int > int (VectorXY)
+                { 0x70, (byte)ExprToken.InternalUnresolved }, // int > int (VectorXZ)
+                { 0x71, (byte)ExprToken.InternalUnresolved }, // int > int (VectorYZ)
+            };
+#endif
+            internal bool IsUsingInlinedPrimitiveCasting()
+            {
+#if DNF
+                if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF) return true;
+#endif
+                return Package.Version < VPrimitiveCastToken;
+            }
+
             private void SetupByteCodeMap()
             {
-#if UE1
-                if (Package.Version < VPrimitiveCastToken)
+#if UE1 || DNF
+                if (IsUsingInlinedPrimitiveCasting())
                 {
                     // Map all old CastTokens that were expressed as an ExprToken
                     _ByteCodeMap = new Dictionary<byte, byte>
@@ -424,6 +516,9 @@ private void SetupByteCodeMap()
 #if BIOSHOCK
                 if (Package.Build == UnrealPackage.GameBuild.BuildName.BioShock) _ByteCodeMap = ByteCodeMap_BuildBs;
 #endif
+#if DNF
+                if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF) _ByteCodeMap = ByteCodeMap_BuildDnf;
+#endif
 #if MOH
                 if (Package.Build == UnrealPackage.GameBuild.BuildName.MOH)
                     // TODO: Incomplete byte-code map
diff --git a/src/Core/Tokens/CastTokens.cs b/src/Core/Tokens/CastTokens.cs
index 04dbd11..0e3e782 100644
--- a/src/Core/Tokens/CastTokens.cs
+++ b/src/Core/Tokens/CastTokens.cs
@@ -60,7 +60,7 @@ public class PrimitiveCastToken : Token
 
                 public override void Deserialize(IUnrealStream stream)
                 {
-                    if (stream.Version >= VPrimitiveCastToken)
+                    if (!Decompiler.IsUsingInlinedPrimitiveCasting())
                     {
                         CastOpCode = (CastToken)stream.ReadByte();
                         Decompiler.AlignSize(sizeof(byte));
diff --git a/src/Core/Tokens/ContextTokens.cs b/src/Core/Tokens/ContextTokens.cs
index 940faeb..883811c 100644
--- a/src/Core/Tokens/ContextTokens.cs
+++ b/src/Core/Tokens/ContextTokens.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using UELib.Annotations;
+using UELib.Types;
 
 namespace UELib.Core
 {
@@ -9,26 +10,25 @@ public partial class UByteCodeDecompiler
         {
             public class ContextToken : Token
             {
-                // Definitely not in UT3(512), APB, CrimeCraft, GoW2, MoonBase and Singularity.
-                // Greater or Equal than
-                private const ushort VSizeByteMoved = 588;
-
+                public ushort PropertyType;
+                
                 public override void Deserialize(IUnrealStream stream)
                 {
-                    bool propertyAdded = stream.Version >= VSizeByteMoved
-#if TERA
-                                         && stream.Package.Build != UnrealPackage.GameBuild.BuildName.Tera
-#endif
-                        ;
-
                     // A.?
                     DeserializeNext();
 
                     // SkipSize
                     stream.ReadUInt16();
                     Decompiler.AlignSize(sizeof(ushort));
+                    
 
                     // Doesn't seem to exist in APB
+                    // Definitely not in UT3(512), APB, CrimeCraft, GoW2, MoonBase and Singularity.
+                    bool propertyAdded = stream.Version >= 588
+#if TERA
+                                         && stream.Package.Build != UnrealPackage.GameBuild.BuildName.Tera
+#endif
+                        ;
                     if (propertyAdded)
                     {
                         // Property
@@ -36,14 +36,19 @@ public override void Deserialize(IUnrealStream stream)
                         Decompiler.AlignObjectSize();
                     }
 
-                    // PropertyType
-                    stream.ReadByte();
-                    Decompiler.AlignSize(sizeof(byte));
-
-                    // Additional byte in APB?
-                    if (stream.Version > 512 && !propertyAdded)
+                    // FIXME: Thinking of it... this appears to be identical to the changes found in SwitchToken, but the existing versions are different?.
+                    if ((stream.Version >= 512 && !propertyAdded)
+#if DNF
+                        || stream.Package.Build == UnrealPackage.GameBuild.BuildName.DNF
+#endif
+                       )
                     {
-                        stream.ReadByte();
+                        PropertyType = stream.ReadUInt16();
+                        Decompiler.AlignSize(sizeof(ushort));
+                    }
+                    else
+                    {
+                        PropertyType = stream.ReadByte();
                         Decompiler.AlignSize(sizeof(byte));
                     }
 
diff --git a/src/Core/Tokens/JumpTokens.cs b/src/Core/Tokens/JumpTokens.cs
index a7a7783..0b02695 100644
--- a/src/Core/Tokens/JumpTokens.cs
+++ b/src/Core/Tokens/JumpTokens.cs
@@ -474,7 +474,11 @@ public override void Deserialize(IUnrealStream stream)
                     }
 
                     // TODO: Corrigate version
-                    if (stream.Version >= 536 && stream.Version <= 587)
+                    if ((stream.Version >= 536 && stream.Version <= 587)
+#if DNF
+                        || stream.Package.Build == UnrealPackage.GameBuild.BuildName.DNF
+#endif
+                        )
                     {
                         PropertyType = stream.ReadUInt16();
                         Decompiler.AlignSize(sizeof(ushort));
diff --git a/src/Eliot.UELib.csproj b/src/Eliot.UELib.csproj
index 90b57c6..86a054c 100644
--- a/src/Eliot.UELib.csproj
+++ b/src/Eliot.UELib.csproj
@@ -73,7 +73,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'DecompileDebug|AnyCPU'">
     <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;DECOMPILE BINARYMETADATA Forms DEBUG_TEST DEBUG_TOKENPOSITIONS DEBUG_HIDDENTOKENS DEBUG_NESTS DEBUG_FUNCTIONINFO UE1 UE2 UE3 VENGEANCE SWAT4 UNREAL2 INFINITYBLADE BORDERLANDS2 GOW2 DEBUG_TEST APB SPECIALFORCE2 XIII SINGULARITY THIEF_DS DEUSEX_IW BORDERLANDS MIRRORSEDGE BIOSHOCK HAWKEN UT DISHONORED REMEMBERME ALPHAPROTOCOL VANGUARD TERA MKKE TRANSFORMERS XCOM2 DD2 DCUO AA2 SPELLBORN BATMAN MOH ROCKETLEAGUE</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;DECOMPILE BINARYMETADATA Forms UE1 UE2 UE3 UE4 DEBUG_TEST DEBUG_TOKENPOSITIONS DEBUG_HIDDENTOKENS DEBUG_NESTS DEBUG_FUNCTIONINFO UE1 UE2 UE3 VENGEANCE SWAT4 UNREAL2 INFINITYBLADE BORDERLANDS2 GOW2 DEBUG_TEST APB SPECIALFORCE2 XIII SINGULARITY THIEF_DS DEUSEX_IW BORDERLANDS MIRRORSEDGE BIOSHOCK HAWKEN UT DISHONORED REMEMBERME ALPHAPROTOCOL VANGUARD TERA MKKE TRANSFORMERS XCOM2 DD2 DCUO AA2 SPELLBORN BATMAN MOH ROCKETLEAGUE DNF</DefineConstants>
     <DocumentationFile>
     </DocumentationFile>
     <Optimize>false</Optimize>
@@ -257,7 +257,7 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties BuildVersion_UpdateAssemblyVersion="True" BuildVersion_UpdateFileVersion="True" BuildVersion_BuildVersioningStyle="None.None.Increment.None" />
+      <UserProperties BuildVersion_BuildVersioningStyle="None.None.Increment.None" BuildVersion_UpdateFileVersion="True" BuildVersion_UpdateAssemblyVersion="True" />
     </VisualStudio>
   </ProjectExtensions>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/src/UnrealTokens.cs b/src/UnrealTokens.cs
index f57e298..e1cf673 100644
--- a/src/UnrealTokens.cs
+++ b/src/UnrealTokens.cs
@@ -191,8 +191,8 @@ public enum ExprToken : ushort
         Unused5F                = 0x5F,
         #endregion
 
-        ExtendedNative          = 0x60,
-        FirstNative             = 0x70,
+        ExtendedNative          = 0x72,
+        FirstNative             = 0x90,
         MaxNative               = 0x1000,
         
         MaxNonNative            = ExtendedNative - 1,

From c6c1537c9ef693b534ec5eac89e08c3af7eac3b7 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Thu, 4 Aug 2022 17:23:29 +0200
Subject: [PATCH 03/11] Fix Incorrect bytecode being displayed for unresolved
 native functions.

---
 src/ByteCodeDecompiler.cs         |  9 +++++++--
 src/Core/Tokens/FunctionTokens.cs | 32 +++----------------------------
 2 files changed, 10 insertions(+), 31 deletions(-)

diff --git a/src/ByteCodeDecompiler.cs b/src/ByteCodeDecompiler.cs
index e4c2f2f..cd3db57 100644
--- a/src/ByteCodeDecompiler.cs
+++ b/src/ByteCodeDecompiler.cs
@@ -639,10 +639,15 @@ private void DeserializeDebugToken()
 
             private NativeFunctionToken CreateNativeToken(ushort nativeIndex)
             {
-                var nativeTableItem = _Container.Package.NTLPackage?.FindTableItem(nativeIndex);
+                var nativeTableItem = _Container.Package.NTLPackage?.FindTableItem(nativeIndex) ?? new NativeTableItem
+                {
+                    Type = FunctionType.Function,
+                    Name = $"__NFUN_{nativeIndex}__",
+                    ByteToken = nativeIndex
+                };
                 return new NativeFunctionToken
                 {
-                    NativeItem = nativeTableItem
+                    NativeItem = nativeTableItem,
                 };
             }
 
diff --git a/src/Core/Tokens/FunctionTokens.cs b/src/Core/Tokens/FunctionTokens.cs
index 11bd698..8e6fd1f 100644
--- a/src/Core/Tokens/FunctionTokens.cs
+++ b/src/Core/Tokens/FunctionTokens.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace UELib.Core
@@ -20,6 +21,7 @@ protected void DeserializeCall()
                     Decompiler.DeserializeDebugToken();
                 }
 
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 private void DeserializeParms()
                 {
 #pragma warning disable 642
@@ -310,35 +312,7 @@ public class NativeFunctionToken : FunctionToken
 
                 public override void Deserialize(IUnrealStream stream)
                 {
-                    if (NativeItem == null)
-                    {
-                        NativeItem = new NativeTableItem
-                        {
-                            Type = FunctionType.Function,
-                            Name = "UnresolvedNativeFunction_" + RepresentToken,
-                            ByteToken = RepresentToken
-                        };
-                    }
-
-                    switch (NativeItem.Type)
-                    {
-                        case FunctionType.Function:
-                            DeserializeCall();
-                            break;
-
-                        case FunctionType.PreOperator:
-                        case FunctionType.PostOperator:
-                            DeserializeUnaryOperator();
-                            break;
-
-                        case FunctionType.Operator:
-                            DeserializeBinaryOperator();
-                            break;
-
-                        default:
-                            DeserializeCall();
-                            break;
-                    }
+                    DeserializeCall();
                 }
 
                 public override string Decompile()

From cacaf9bebc6331a3e42b436402bbf884fe374d90 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Thu, 4 Aug 2022 18:01:18 +0200
Subject: [PATCH 04/11] Fix issues with the NTL generator.

---
 src/Core/Classes/UFunction.cs |  2 +-
 src/NativesTablePackage.cs    | 14 ++++++--------
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/Core/Classes/UFunction.cs b/src/Core/Classes/UFunction.cs
index 29c8d17..a540988 100644
--- a/src/Core/Classes/UFunction.cs
+++ b/src/Core/Classes/UFunction.cs
@@ -136,7 +136,7 @@ protected override void Deserialize()
             {
                 // HACK: Workaround for packages that have stripped FriendlyName data.
                 // FIXME: Operator names need to be translated.
-                FriendlyName = Table.ObjectName;
+                if (FriendlyName == null) FriendlyName = Table.ObjectName;
             }
         }
 
diff --git a/src/NativesTablePackage.cs b/src/NativesTablePackage.cs
index b8d7334..3ab35ab 100644
--- a/src/NativesTablePackage.cs
+++ b/src/NativesTablePackage.cs
@@ -22,11 +22,7 @@ public NativeTableItem()
         [PublicAPI]
         public NativeTableItem(UFunction function)
         {
-            if (function.IsOperator())
-            {
-                Type = FunctionType.Operator;
-            }
-            else if (function.IsPost())
+            if (function.IsPost())
             {
                 Type = FunctionType.PostOperator;
             }
@@ -34,6 +30,10 @@ public NativeTableItem(UFunction function)
             {
                 Type = FunctionType.PreOperator;
             }
+            else if (function.IsOperator())
+            {
+                Type = FunctionType.Operator;
+            }
             else
             {
                 Type = FunctionType.Function;
@@ -41,9 +41,7 @@ public NativeTableItem(UFunction function)
 
             OperPrecedence = function.OperPrecedence;
             ByteToken = function.NativeToken;
-            Name = Type == FunctionType.Function
-                ? function.Name
-                : function.FriendlyName;
+            Name = function.FriendlyName;
         }
     }
 

From 65b4feb57d636cdbc48a9b95d406eec22068b4e9 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Thu, 4 Aug 2022 18:03:59 +0200
Subject: [PATCH 05/11] Allow ExtendedNative and FirstNative values to be set
 at run time.

---
 src/ByteCodeDecompiler.cs | 9 ++++++---
 src/UnrealTokens.cs       | 7 +++----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/ByteCodeDecompiler.cs b/src/ByteCodeDecompiler.cs
index cd3db57..402d48f 100644
--- a/src/ByteCodeDecompiler.cs
+++ b/src/ByteCodeDecompiler.cs
@@ -59,6 +59,9 @@ public UByteCodeDecompiler(UStruct container)
 
             #region Deserialize
 
+            private byte _ExtendedNative = (byte)ExprToken.ExtendedNative;
+            private byte _FirstNative = (byte)ExprToken.FirstNative;
+
             /// <summary>
             /// The current simulated-memory-aligned position in @Buffer.
             /// </summary>
@@ -662,9 +665,9 @@ private Token DeserializeNext(byte tokenCode = byte.MaxValue)
 
                 byte serializedByte = tokenCode;
                 Token token;
-                if (tokenCode >= (byte)ExprToken.ExtendedNative)
+                if (tokenCode >= _ExtendedNative)
                 {
-                    if (tokenCode >= (byte)ExprToken.FirstNative)
+                    if (tokenCode >= _FirstNative)
                     {
                         token = CreateNativeToken(tokenCode);
                     }
@@ -673,7 +676,7 @@ private Token DeserializeNext(byte tokenCode = byte.MaxValue)
                         byte extendedByte = Buffer.ReadByte();
                         AlignSize(sizeof(byte));
 
-                        var nativeIndex = (ushort)(((tokenCode - (byte)ExprToken.ExtendedNative) << 8) | extendedByte);
+                        var nativeIndex = (ushort)(((tokenCode - _ExtendedNative) << 8) | extendedByte);
                         Debug.Assert(nativeIndex < (ushort)ExprToken.MaxNative);
                         token = CreateNativeToken(nativeIndex);
                     }
diff --git a/src/UnrealTokens.cs b/src/UnrealTokens.cs
index e1cf673..0c08463 100644
--- a/src/UnrealTokens.cs
+++ b/src/UnrealTokens.cs
@@ -191,12 +191,11 @@ public enum ExprToken : ushort
         Unused5F                = 0x5F,
         #endregion
 
-        ExtendedNative          = 0x72,
-        FirstNative             = 0x90,
+        ExtendedNative          = 0x60,
+        FirstNative             = 0x70,
         MaxNative               = 0x1000,
         
-        MaxNonNative            = ExtendedNative - 1,
-        InternalUnresolved      = MaxNonNative,
+        InternalUnresolved      = 0xFF,
         Unused                  = InternalUnresolved,
     }
 

From 40f48c69338f470c803fae50a6141f99c5072826 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Thu, 4 Aug 2022 18:04:44 +0200
Subject: [PATCH 06/11] Support for DNF's FStateFrame (untested). #49

---
 src/Core/UStateFrame.cs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/Core/UStateFrame.cs b/src/Core/UStateFrame.cs
index 50ef56e..7c8678a 100644
--- a/src/Core/UStateFrame.cs
+++ b/src/Core/UStateFrame.cs
@@ -30,6 +30,11 @@ public void Deserialize(IUnrealStream stream)
             LatentAction = stream.Version < VLatentActionReduced
                 ? stream.ReadUInt32()
                 : stream.ReadUInt16();
+            if (stream.Package.Build == UnrealPackage.GameBuild.BuildName.DNF &&
+                stream.LicenseeVersion >= 25)
+            {
+                uint dnfUInt32 = stream.ReadUInt32();
+            }
             if (stream.Version >= VStateStack) stream.ReadArray(out StateStack);
             if (Node != null) Offset = stream.ReadIndex();
         }

From a5afba9cf87377a85791ccb88fb43525e4a2ab9c Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Thu, 4 Aug 2022 18:05:54 +0200
Subject: [PATCH 07/11] Implement all tokens for DNF's extended bytecode set
 #49.

---
 src/Branch/UE2/DNF/Tokens/BreakpointToken.cs  |  15 +
 .../UE2/DNF/Tokens/DynamicArrayEmptyToken.cs  |  19 ++
 .../UE2/DNF/Tokens/IntConstWordToken.cs       |  21 ++
 .../UE2/DNF/Tokens/RotConstBytesToken.cs      |  18 ++
 .../UE2/DNF/Tokens/RotConstPitchToken.cs      |  21 ++
 .../UE2/DNF/Tokens/RotConstRollToken.cs       |  21 ++
 src/Branch/UE2/DNF/Tokens/RotConstYawToken.cs |  21 ++
 .../UE2/DNF/Tokens/RotConstZeroToken.cs       |  12 +
 .../UE2/DNF/Tokens/VectorConstUnitZToken.cs   |  13 +
 .../UE2/DNF/Tokens/VectorConstZeroToken.cs    |  12 +
 src/Branch/UE2/DNF/Tokens/VectorXToken.cs     |  21 ++
 src/Branch/UE2/DNF/Tokens/VectorXYToken.cs    |  24 ++
 src/Branch/UE2/DNF/Tokens/VectorXZToken.cs    |  24 ++
 src/Branch/UE2/DNF/Tokens/VectorYToken.cs     |  21 ++
 src/Branch/UE2/DNF/Tokens/VectorYZToken.cs    |  24 ++
 src/Branch/UE2/DNF/Tokens/VectorZToken.cs     |  21 ++
 src/ByteCodeDecompiler.cs                     | 257 +++++++++++++-----
 src/Eliot.UELib.csproj                        |  18 +-
 18 files changed, 509 insertions(+), 74 deletions(-)
 create mode 100644 src/Branch/UE2/DNF/Tokens/BreakpointToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/DynamicArrayEmptyToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/IntConstWordToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/RotConstBytesToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/RotConstPitchToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/RotConstRollToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/RotConstYawToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/RotConstZeroToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/VectorConstUnitZToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/VectorConstZeroToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/VectorXToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/VectorXYToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/VectorXZToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/VectorYToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/VectorYZToken.cs
 create mode 100644 src/Branch/UE2/DNF/Tokens/VectorZToken.cs

diff --git a/src/Branch/UE2/DNF/Tokens/BreakpointToken.cs b/src/Branch/UE2/DNF/Tokens/BreakpointToken.cs
new file mode 100644
index 0000000..4c90ef0
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/BreakpointToken.cs
@@ -0,0 +1,15 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class BreakpointToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public override string Decompile()
+        {
+            // TODO:
+            Decompiler.PreComment = "// Breakpoint";
+            Decompiler.MarkSemicolon();
+            return "@UnknownSyntax";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/DynamicArrayEmptyToken.cs b/src/Branch/UE2/DNF/Tokens/DynamicArrayEmptyToken.cs
new file mode 100644
index 0000000..f5d81ec
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/DynamicArrayEmptyToken.cs
@@ -0,0 +1,19 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class DynamicArrayEmptyToken : UStruct.UByteCodeDecompiler.DynamicArrayMethodToken
+    {
+        public override void Deserialize(IUnrealStream stream)
+        {
+            // Array
+            DeserializeNext();
+        }
+
+        public override string Decompile()
+        {
+            Decompiler.MarkSemicolon();
+            return $"{DecompileNext()}.Empty()";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/IntConstWordToken.cs b/src/Branch/UE2/DNF/Tokens/IntConstWordToken.cs
new file mode 100644
index 0000000..5f395b9
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/IntConstWordToken.cs
@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class IntConstWordToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public ushort Value;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Value = stream.ReadUInt16();
+            Decompiler.AlignSize(sizeof(ushort));
+        }
+
+        public override string Decompile()
+        {
+            return PropertyDisplay.FormatLiteral(Value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/RotConstBytesToken.cs b/src/Branch/UE2/DNF/Tokens/RotConstBytesToken.cs
new file mode 100644
index 0000000..28ac5a8
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/RotConstBytesToken.cs
@@ -0,0 +1,18 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstBytesToken : UStruct.UByteCodeDecompiler.RotationConstToken
+    {
+        public override void Deserialize(IUnrealStream stream)
+        {
+            // FIXME: These must have been compressed right?
+            Value.Pitch = stream.ReadByte(); 
+            Decompiler.AlignSize(sizeof(byte));
+            Value.Roll = stream.ReadByte(); 
+            Decompiler.AlignSize(sizeof(byte));
+            Value.Yaw = stream.ReadByte(); 
+            Decompiler.AlignSize(sizeof(byte));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/RotConstPitchToken.cs b/src/Branch/UE2/DNF/Tokens/RotConstPitchToken.cs
new file mode 100644
index 0000000..888a666
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/RotConstPitchToken.cs
@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstPitchToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public int Pitch;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Pitch = stream.ReadInt32();
+            Decompiler.AlignSize(sizeof(int));
+        }
+
+        public override string Decompile()
+        {
+            return $"rotpitch({PropertyDisplay.FormatLiteral(Pitch)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/RotConstRollToken.cs b/src/Branch/UE2/DNF/Tokens/RotConstRollToken.cs
new file mode 100644
index 0000000..f610476
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/RotConstRollToken.cs
@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstRollToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public int Roll;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Roll = stream.ReadInt32();
+            Decompiler.AlignSize(sizeof(int));
+        }
+
+        public override string Decompile()
+        {
+            return $"rotroll({PropertyDisplay.FormatLiteral(Roll)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/RotConstYawToken.cs b/src/Branch/UE2/DNF/Tokens/RotConstYawToken.cs
new file mode 100644
index 0000000..2f76cde
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/RotConstYawToken.cs
@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstYawToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public int Yaw;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Yaw = stream.ReadInt32();
+            Decompiler.AlignSize(sizeof(int));
+        }
+
+        public override string Decompile()
+        {
+            return $"rotyaw({PropertyDisplay.FormatLiteral(Yaw)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/RotConstZeroToken.cs b/src/Branch/UE2/DNF/Tokens/RotConstZeroToken.cs
new file mode 100644
index 0000000..e3556b8
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/RotConstZeroToken.cs
@@ -0,0 +1,12 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstZeroToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public override string Decompile()
+        {
+            return "rot(0, 0, 0)";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/VectorConstUnitZToken.cs b/src/Branch/UE2/DNF/Tokens/VectorConstUnitZToken.cs
new file mode 100644
index 0000000..b134382
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/VectorConstUnitZToken.cs
@@ -0,0 +1,13 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorConstUnitZToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public override string Decompile()
+        {
+            // TODO
+            return "@UnknownSyntax";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/VectorConstZeroToken.cs b/src/Branch/UE2/DNF/Tokens/VectorConstZeroToken.cs
new file mode 100644
index 0000000..bbe1c68
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/VectorConstZeroToken.cs
@@ -0,0 +1,12 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorConstZeroToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public override string Decompile()
+        {
+            return "vect(0, 0, 0)";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/VectorXToken.cs b/src/Branch/UE2/DNF/Tokens/VectorXToken.cs
new file mode 100644
index 0000000..1d42bb0
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/VectorXToken.cs
@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorXToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float X;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            X = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectx({PropertyDisplay.FormatLiteral(X)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/VectorXYToken.cs b/src/Branch/UE2/DNF/Tokens/VectorXYToken.cs
new file mode 100644
index 0000000..ebf6bbf
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/VectorXYToken.cs
@@ -0,0 +1,24 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorXYToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float X, Y;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            X = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+
+            Y = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectxy({PropertyDisplay.FormatLiteral(X)}, {PropertyDisplay.FormatLiteral(Y)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/VectorXZToken.cs b/src/Branch/UE2/DNF/Tokens/VectorXZToken.cs
new file mode 100644
index 0000000..5394d60
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/VectorXZToken.cs
@@ -0,0 +1,24 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorXZToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float X, Z;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            X = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+
+            Z = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectxz({PropertyDisplay.FormatLiteral(X)}, {PropertyDisplay.FormatLiteral(Z)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/VectorYToken.cs b/src/Branch/UE2/DNF/Tokens/VectorYToken.cs
new file mode 100644
index 0000000..2bab958
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/VectorYToken.cs
@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorYToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float Y;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Y = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vecty({PropertyDisplay.FormatLiteral(Y)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/VectorYZToken.cs b/src/Branch/UE2/DNF/Tokens/VectorYZToken.cs
new file mode 100644
index 0000000..adc44aa
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/VectorYZToken.cs
@@ -0,0 +1,24 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorYZToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float Y, Z;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Y = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+
+            Z = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectyz({PropertyDisplay.FormatLiteral(Y)}, {PropertyDisplay.FormatLiteral(Z)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Branch/UE2/DNF/Tokens/VectorZToken.cs b/src/Branch/UE2/DNF/Tokens/VectorZToken.cs
new file mode 100644
index 0000000..b5b56f6
--- /dev/null
+++ b/src/Branch/UE2/DNF/Tokens/VectorZToken.cs
@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorZToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float Z;
+        
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Z = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectz({PropertyDisplay.FormatLiteral(Z)})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ByteCodeDecompiler.cs b/src/ByteCodeDecompiler.cs
index 402d48f..85063f1 100644
--- a/src/ByteCodeDecompiler.cs
+++ b/src/ByteCodeDecompiler.cs
@@ -6,6 +6,7 @@
 using System.IO;
 using System.Runtime.CompilerServices;
 using UELib.Annotations;
+using UELib.Branch.UE2.DNF.Tokens;
 using UELib.Flags;
 using UELib.Tokens;
 
@@ -13,7 +14,6 @@ namespace UELib.Core
 {
     using System.Linq;
     using System.Text;
-    using static UStruct.UByteCodeDecompiler;
 
     public partial class UStruct
     {
@@ -98,19 +98,19 @@ private void SetupMemorySizes()
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            private void AlignSize(int size)
+            internal void AlignSize(int size)
             {
                 CodePosition += size;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            private void AlignNameSize()
+            internal void AlignNameSize()
             {
                 CodePosition += _NameMemorySize;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            private void AlignObjectSize()
+            internal void AlignObjectSize()
             {
                 CodePosition += _ObjectMemorySize;
             }
@@ -395,26 +395,26 @@ private void AlignObjectSize()
                 { 0x5E, (byte)ExprToken.DelegateFunction }, // object > name
                 { 0x5F, (byte)ExprToken.DelegateProperty }, // name
                 { 0x60, (byte)ExprToken.LetDelegate }, // expr > expr
-                { 0x61, (byte)ExprToken.InternalUnresolved }, // void (VectorConstZero)
-                { 0x62, (byte)ExprToken.InternalUnresolved }, // void (VectorConstUnitZ)
-                { 0x63, (byte)ExprToken.InternalUnresolved }, // void (RotConstZero)
-                { 0x64, (byte)ExprToken.InternalUnresolved }, // ushort (IntConstWord)
-                { 0x65, (byte)ExprToken.InternalUnresolved }, // byte > byte > byte (RotConstBytes)
-                { 0x66, (byte)ExprToken.InternalUnresolved }, // keyword > expr (DynArrayEmpty)
-                { 0x67, (byte)ExprToken.InternalUnresolved }, // void (Breakpoint)
+                //{ 0x61, (byte)ExprToken.InternalUnresolved }, // void (VectorConstZero)
+                //{ 0x62, (byte)ExprToken.InternalUnresolved }, // void (VectorConstUnitZ)
+                //{ 0x63, (byte)ExprToken.InternalUnresolved }, // void (RotConstZero)
+                //{ 0x64, (byte)ExprToken.InternalUnresolved }, // ushort (IntConstWord)
+                //{ 0x65, (byte)ExprToken.InternalUnresolved }, // byte > byte > byte (RotConstBytes)
+                //{ 0x66, (byte)ExprToken.InternalUnresolved }, // keyword > expr (DynArrayEmpty)
+                //{ 0x67, (byte)ExprToken.InternalUnresolved }, // void (Breakpoint)
                 { 0x68, (byte)ExprToken.Unused },
-                { 0x69, (byte)ExprToken.InternalUnresolved }, // int (RotConstPitch)
-                { 0x6A, (byte)ExprToken.InternalUnresolved }, // int (RotConstYaw)
-                { 0x6B, (byte)ExprToken.InternalUnresolved }, // int (RotConstRoll)
-                { 0x6C, (byte)ExprToken.InternalUnresolved }, // int (VectorX)
-                { 0x6D, (byte)ExprToken.InternalUnresolved }, // int (VectorY)
-                { 0x6E, (byte)ExprToken.InternalUnresolved }, // int (VectorZ)
-                { 0x6F, (byte)ExprToken.InternalUnresolved }, // int > int (VectorXY)
-                { 0x70, (byte)ExprToken.InternalUnresolved }, // int > int (VectorXZ)
-                { 0x71, (byte)ExprToken.InternalUnresolved }, // int > int (VectorYZ)
+                //{ 0x69, (byte)ExprToken.InternalUnresolved }, // int (RotConstPitch)
+                //{ 0x6A, (byte)ExprToken.InternalUnresolved }, // int (RotConstYaw)
+                //{ 0x6B, (byte)ExprToken.InternalUnresolved }, // int (RotConstRoll)
+                //{ 0x6C, (byte)ExprToken.InternalUnresolved }, // int (VectorX)
+                //{ 0x6D, (byte)ExprToken.InternalUnresolved }, // int (VectorY)
+                //{ 0x6E, (byte)ExprToken.InternalUnresolved }, // int (VectorZ)
+                //{ 0x6F, (byte)ExprToken.InternalUnresolved }, // int > int (VectorXY)
+                //{ 0x70, (byte)ExprToken.InternalUnresolved }, // int > int (VectorXZ)
+                //{ 0x71, (byte)ExprToken.InternalUnresolved }, // int > int (VectorYZ)
             };
 #endif
-            internal bool IsUsingInlinedPrimitiveCasting()
+            private bool IsUsingInlinedPrimitiveCasting()
             {
 #if DNF
                 if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF) return true;
@@ -424,54 +424,6 @@ internal bool IsUsingInlinedPrimitiveCasting()
 
             private void SetupByteCodeMap()
             {
-#if UE1 || DNF
-                if (IsUsingInlinedPrimitiveCasting())
-                {
-                    // Map all old CastTokens that were expressed as an ExprToken
-                    _ByteCodeMap = new Dictionary<byte, byte>
-                    {
-                        // TODO: Confirm if these are correct for UE1
-                        { (byte)CastToken.RotatorToVector, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.ByteToInt, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.ByteToBool, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.ByteToFloat, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.IntToByte, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.IntToBool, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.IntToFloat, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.BoolToByte, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.BoolToInt, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.BoolToFloat, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.FloatToByte, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.FloatToInt, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.FloatToBool, (byte)ExprToken.PrimitiveCast },
-
-                        { (byte)CastToken.ObjectToInterface, (byte)ExprToken.PrimitiveCast }, // Actually StringToName
-
-                        { (byte)CastToken.ObjectToBool, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.NameToBool, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.StringToByte, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.StringToInt, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.StringToBool, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.StringToFloat, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.StringToVector, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.StringToRotator, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.VectorToBool, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.VectorToRotator, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.RotatorToBool, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.ByteToString, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.IntToString, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.BoolToString, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.FloatToString, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.ObjectToString, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.NameToString, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.VectorToString, (byte)ExprToken.PrimitiveCast },
-                        { (byte)CastToken.RotatorToString, (byte)ExprToken.PrimitiveCast },
-
-                        { (byte)CastToken.DelegateToString, (byte)ExprToken.PrimitiveCast } // StringToName in HP2?
-                    };
-                    return;
-                }
-#endif
 #if AA2
                 if (Package.Build == UnrealPackage.GameBuild.BuildName.AA2)
                 {
@@ -514,16 +466,21 @@ private void SetupByteCodeMap()
 #if APB
                 if (Package.Build == UnrealPackage.GameBuild.BuildName.APB &&
                     Package.LicenseeVersion >= 32)
+                {
                     _ByteCodeMap = ByteCodeMap_BuildApb;
+                    return;
+                }
 #endif
 #if BIOSHOCK
-                if (Package.Build == UnrealPackage.GameBuild.BuildName.BioShock) _ByteCodeMap = ByteCodeMap_BuildBs;
-#endif
-#if DNF
-                if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF) _ByteCodeMap = ByteCodeMap_BuildDnf;
+                if (Package.Build == UnrealPackage.GameBuild.BuildName.BioShock)
+                {
+                    _ByteCodeMap = ByteCodeMap_BuildBs;
+                    return;
+                }
 #endif
 #if MOH
                 if (Package.Build == UnrealPackage.GameBuild.BuildName.MOH)
+                {
                     // TODO: Incomplete byte-code map
                     _ByteCodeMap = new Dictionary<byte, byte>
                     {
@@ -544,6 +501,75 @@ private void SetupByteCodeMap()
                         { 0x4B, (byte)ExprToken.NativeParm }
                         //{ 0x4F, (byte)ExprToken.BoolVariable }
                     };
+                    return;
+                }
+#endif
+#if DNF
+                if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF)
+                {
+                    _ExtendedNative = 0x80;
+                    _FirstNative = 0x90;
+                    _ByteCodeMap = ByteCodeMap_BuildDnf;
+                }
+#endif
+#if UE1 || DNF
+                if (IsUsingInlinedPrimitiveCasting())
+                {
+                    // Map all old CastTokens that were expressed as an ExprToken
+                    var castBytesMap = new Dictionary<byte, byte>
+                    {
+                        // TODO: Confirm if these are correct for UE1
+                        { (byte)CastToken.RotatorToVector, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.ByteToInt, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.ByteToBool, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.ByteToFloat, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.IntToByte, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.IntToBool, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.IntToFloat, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.BoolToByte, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.BoolToInt, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.BoolToFloat, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.FloatToByte, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.FloatToInt, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.FloatToBool, (byte)ExprToken.PrimitiveCast },
+
+                        { (byte)CastToken.ObjectToInterface, (byte)ExprToken.PrimitiveCast }, // Actually StringToName
+
+                        { (byte)CastToken.ObjectToBool, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.NameToBool, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.StringToByte, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.StringToInt, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.StringToBool, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.StringToFloat, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.StringToVector, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.StringToRotator, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.VectorToBool, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.VectorToRotator, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.RotatorToBool, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.ByteToString, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.IntToString, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.BoolToString, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.FloatToString, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.ObjectToString, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.NameToString, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.VectorToString, (byte)ExprToken.PrimitiveCast },
+                        { (byte)CastToken.RotatorToString, (byte)ExprToken.PrimitiveCast },
+
+                        { (byte)CastToken.DelegateToString, (byte)ExprToken.PrimitiveCast } // StringToName in HP2?
+                    };
+
+                    if (_ByteCodeMap == null)
+                    {
+                        _ByteCodeMap = castBytesMap;
+                    }
+                    else
+                    {
+                        foreach (var pair in castBytesMap)
+                        {
+                            _ByteCodeMap[pair.Key] = pair.Value;
+                        }
+                    }
+                }
 #endif
             }
 
@@ -1138,11 +1164,91 @@ private Token DeserializeNext(byte tokenCode = byte.MaxValue)
                         #endregion
 
                         default:
+#if DNF
+                            // DNF has extended the ExtendNative tokens set.
+                            // FIXME: Re-factor once we have a better ByteCodeToToken factory.
+                            if (Package.Build == UnrealPackage.GameBuild.BuildName.DNF)
+                            {
+                                switch (tokenCode)
+                                {
+                                    case 0x61:
+                                        token = new VectorConstZeroToken();
+                                        break;
+                                    
+                                    case 0x62:
+                                        token = new VectorConstUnitZToken();
+                                        break;
+                                    
+                                    case 0x63:
+                                        token = new RotConstZeroToken();
+                                        break;
+                                    
+                                    case 0x64:
+                                        token = new IntConstWordToken();
+                                        break;
+                                    
+                                    case 0x65:
+                                        token = new RotConstBytesToken();
+                                        break;
+                                    
+                                    case 0x66:
+                                        token = new DynamicArrayEmptyToken();
+                                        break;
+                                    
+                                    case 0x67:
+                                        token = new BreakpointToken();
+                                        break;
+                                    
+                                    case 0x69:
+                                        token = new RotConstPitchToken();
+                                        break;
+                                    
+                                    case 0x6A:
+                                        token = new RotConstYawToken();
+                                        break;
+                                    
+                                    case 0x6B:
+                                        token = new RotConstRollToken();
+                                        break;
+
+                                    case 0x6C:
+                                        token = new VectorXToken();
+                                        break;
+                                    
+                                    case 0x6D:
+                                        token = new VectorYToken();
+                                        break;
+                                    
+                                    case 0x6E:
+                                        token = new VectorZToken();
+                                        break;
+
+                                    case 0x6F:
+                                        token = new VectorXYToken();
+                                        break;
+
+                                    case 0x70:
+                                        token = new VectorXZToken();
+                                        break;
+
+                                    case 0x71:
+                                        token = new VectorYZToken();
+                                        break;
+                                    
+                                    default:
+                                        token = new UnresolvedToken();
+                                        break;
+                                }
+
+                                goto assertToken;
+                            }
+#endif
                             token = new UnresolvedToken();
                             break;
                     }
                 }
 
+            assertToken:
                 Debug.Assert(token != null);
                 AddToken(token, serializedByte, tokenPosition);
                 return token;
@@ -1374,6 +1480,11 @@ public Token TokenAt(ushort codeOffset)
             public string PreComment;
             public string PostComment;
 
+            public void MarkSemicolon()
+            {
+                _CanAddSemicolon = true;
+            }
+
             public string Decompile()
             {
                 // Make sure that everything is deserialized!
diff --git a/src/Eliot.UELib.csproj b/src/Eliot.UELib.csproj
index 86a054c..7c9b90a 100644
--- a/src/Eliot.UELib.csproj
+++ b/src/Eliot.UELib.csproj
@@ -124,6 +124,7 @@
     <Compile Include="Branch\UE4\EngineBranch.UE4.cs" />
     <Compile Include="Branch\PackageSerializer.cs" />
     <Compile Include="Branch\UE4\PackageSerializer.UE4.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\BreakpointToken.cs" />
     <Compile Include="Core\Classes\Props\Custom\UScriptMapProperty.cs" />
     <Compile Include="Core\Classes\Props\UArrayProperty.cs" />
     <Compile Include="Core\Classes\Props\UBoolProperty.cs" />
@@ -173,6 +174,7 @@
     <Compile Include="Core\UStateFrame.cs" />
     <Compile Include="Branch\UE2\AA2\CryptoDecoder.AA2.cs" />
     <Compile Include="Decoding\CryptoCore.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\DynamicArrayEmptyToken.cs" />
     <Compile Include="Engine\Classes\UBitmapMaterial.cs" />
     <Compile Include="Engine\Classes\UPalette.cs" />
     <Compile Include="Decoding\IBufferDecoder.cs" />
@@ -185,6 +187,7 @@
     <Compile Include="Engine\Classes\UTexture.cs" />
     <Compile Include="Engine\Classes\USound.cs" />
     <Compile Include="GlobalSuppressions.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\IntConstWordToken.cs" />
     <Compile Include="Properties\Annotations.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Core\Classes\UConstDecompiler.cs" />
@@ -209,6 +212,11 @@
     <Compile Include="Core\Classes\UStruct.cs" />
     <Compile Include="Engine\Classes\UFont.cs" />
     <Compile Include="NativesTablePackage.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\RotConstBytesToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\RotConstPitchToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\RotConstRollToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\RotConstYawToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\RotConstZeroToken.cs" />
     <Compile Include="UnrealScript\PropertyDisplay.cs" />
     <Compile Include="UDecompilingState.cs" />
     <Compile Include="Core\Types\UName.cs" />
@@ -228,6 +236,14 @@
     <Compile Include="Core\Tables\UTableItem.cs" />
     <Compile Include="UnrealTokens.cs" />
     <Compile Include="UnrealTypes.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\VectorConstUnitZToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\VectorConstZeroToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\VectorXToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\VectorXYToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\VectorXZToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\VectorYToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\VectorYZToken.cs" />
+    <Compile Include="Branch\UE2\DNF\Tokens\VectorZToken.cs" />
   </ItemGroup>
   <ItemGroup>
     <BootstrapperPackage Include=".NETFramework,Version=v4.0">
@@ -257,7 +273,7 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties BuildVersion_BuildVersioningStyle="None.None.Increment.None" BuildVersion_UpdateFileVersion="True" BuildVersion_UpdateAssemblyVersion="True" />
+      <UserProperties BuildVersion_UpdateAssemblyVersion="True" BuildVersion_UpdateFileVersion="True" BuildVersion_BuildVersioningStyle="None.None.Increment.None" />
     </VisualStudio>
   </ProjectExtensions>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

From fc70e824abe39f333501b7187eaffee8b4c8390b Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Fri, 5 Aug 2022 19:22:35 +0200
Subject: [PATCH 08/11] Implement ReadBool for IUnrealStream.

---
 src/UnrealStream.cs | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/src/UnrealStream.cs b/src/UnrealStream.cs
index 7a2ffe6..5f0a2be 100644
--- a/src/UnrealStream.cs
+++ b/src/UnrealStream.cs
@@ -809,6 +809,12 @@ internal void DisposeBuffer()
     [Obsolete("Don't use directly, in 2.0 these are implemented once in a single shared IUnrealStream")]
     public static class UnrealStreamImplementations
     {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ReadBool(this IUnrealStream stream)
+        {
+            return Convert.ToBoolean(stream.ReadInt32());
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T ReadObject<T>(this IUnrealStream stream) where T : UObject
         {
@@ -1062,7 +1068,13 @@ public static void VersionedDeserialize(this IUnrealStream stream, IUnrealDeseri
             Debug.Assert(stream.Package.Branch.Serializer != null, "stream.Package.Branch.Serializer != null");
             stream.Package.Branch.Serializer.Deserialize(stream, obj);
         }
-
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Read(this IUnrealStream stream, out bool value)
+        {
+            value = ReadBool(stream);
+        }
+        
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void Read<T>(this IUnrealStream stream, out UObject value)
             where T : UObject
@@ -1208,6 +1220,12 @@ public static void Write(this IUnrealStream stream, uint value)
             stream.UW.Write(value);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Write(this IUnrealStream stream, bool value)
+        {
+            stream.UW.Write(Convert.ToInt32(value));
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void Write(this IUnrealStream stream, long value)
         {
@@ -1233,9 +1251,9 @@ public static void WriteIndex(this IUnrealStream stream, int index)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void Write(this IUnrealStream stream, string s)
+        public static void Write(this IUnrealStream stream, string value)
         {
-            stream.UW.WriteString(s);
+            stream.UW.WriteString(value);
         }
     }
 }
\ No newline at end of file

From 7e4ea303be23a5068f8608a0b2a0c0abf76f3de1 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Fri, 5 Aug 2022 19:22:45 +0200
Subject: [PATCH 09/11] Support DNF's UClass.Dependency #49.

---
 src/Core/Classes/UClass.cs           | 44 +++++++++-------
 src/Core/Classes/UClassDecompiler.cs | 76 ++++------------------------
 2 files changed, 37 insertions(+), 83 deletions(-)

diff --git a/src/Core/Classes/UClass.cs b/src/Core/Classes/UClass.cs
index 0315de5..70bdfd7 100644
--- a/src/Core/Classes/UClass.cs
+++ b/src/Core/Classes/UClass.cs
@@ -12,24 +12,37 @@ namespace UELib.Core
     [UnrealRegisterClass]
     public partial class UClass : UState
     {
+        /// <summary>
+        /// Implements FDependency.
+        /// 
+        /// A legacy dependency struct that was used for incremental compilation (UnrealEd).
+        /// </summary>
         public struct Dependency : IUnrealSerializableClass
         {
-            public int Class { get; private set; }
-
+            [NotNull] public UClass Class;
+            public bool IsDeep;
+            public uint ScriptTextCRC;
+            
             public void Serialize(IUnrealStream stream)
             {
-                // TODO: Implement code
+                stream.Write(Class);
+                stream.Write(IsDeep);
+                stream.Write(ScriptTextCRC);
             }
 
             public void Deserialize(IUnrealStream stream)
             {
-                Class = stream.ReadObjectIndex();
-
-                // Deep
-                stream.ReadInt32();
-
-                // ScriptTextCRC
-                stream.ReadUInt32();
+                Class = stream.ReadObject<UClass>();
+#if DNF
+                // No specified version
+                if (stream.Package.Build == UnrealPackage.GameBuild.BuildName.DNF)
+                {
+                    goto skipDeep;
+                }
+#endif
+                IsDeep = stream.ReadBool();
+                skipDeep:
+                ScriptTextCRC = stream.ReadUInt32();
             }
         }
 
@@ -151,10 +164,7 @@ protected override void Deserialize()
 #if SPELLBORN
             if (Package.Build == UnrealPackage.GameBuild.BuildName.Spellborn)
             {
-                _Buffer.ReadArray(out ClassDependencies);
-                Record(nameof(ClassDependencies), ClassDependencies);
-                PackageImports = DeserializeGroup(nameof(PackageImports));
-                goto skipTo61Stuff;
+                goto skipClassGuid;
             }
 #endif
             if (_Buffer.Version >= 276)
@@ -171,6 +181,7 @@ protected override void Deserialize()
                 Record(nameof(ClassGuid), ClassGuid);
             }
 
+        skipClassGuid:
             if (_Buffer.Version < 248)
             {
                 _Buffer.ReadArray(out ClassDependencies);
@@ -178,7 +189,6 @@ protected override void Deserialize()
                 PackageImports = DeserializeGroup(nameof(PackageImports));
             }
 
-        skipTo61Stuff:
             if (_Buffer.Version >= 62)
             {
                 // Class Name Extends Super.Name Within _WithinIndex
@@ -274,7 +284,7 @@ protected override void Deserialize()
                            )
                         {
                             // bForceScriptOrder
-                            ForceScriptOrder = _Buffer.ReadInt32() > 0;
+                            ForceScriptOrder = _Buffer.ReadBool();
                             Record(nameof(ForceScriptOrder), ForceScriptOrder);
                         }
 #if DD2
@@ -367,7 +377,7 @@ protected override void Deserialize()
             {
                 string dummy = _Buffer.ReadName();
                 Record("dummy", dummy);
-                bool isCooked = _Buffer.ReadInt32() > 0;
+                bool isCooked = _Buffer.ReadBool();
                 Record("isCooked", isCooked);
             }
 #endif
diff --git a/src/Core/Classes/UClassDecompiler.cs b/src/Core/Classes/UClassDecompiler.cs
index d033545..d25d2c9 100644
--- a/src/Core/Classes/UClassDecompiler.cs
+++ b/src/Core/Classes/UClassDecompiler.cs
@@ -105,66 +105,22 @@ public override string Decompile()
             return content;
         }
 
+        [Obsolete]
         public string GetDependencies()
         {
-            if (ClassDependencies == null)
-                return string.Empty;
-
-            var output = string.Empty;
-            foreach (var dep in ClassDependencies)
-            {
-                var obj = GetIndexObject(dep.Class);
-                if (obj != null)
-                {
-                    output += $" *\t{obj.GetClassName()} {obj.GetOuterGroup()}\r\n";
-                }
-            }
-
-            return output.Length != 0 ? "Class Dependencies:\r\n" + output + " *" : string.Empty;
+            throw new NotImplementedException();
         }
 
+        [Obsolete]
         private string GetImports()
         {
-            if (PackageImports == null)
-                return string.Empty;
-
-            var output = string.Empty;
-            foreach (int packageImport in PackageImports)
-            {
-                output += " *\t" + Package.Names[packageImport].Name + "\r\n";
-                /*for( int j = 1; j < (i + i) && (j + (i + i)) < PackageImportsList.Count; ++ j )
-                {
-                    Output += " *\t\t\t" + Owner.NameTableList[PackageImportsList[i + j]].Name + "\r\n";
-                }
-                i += i;*/
-            }
-
-            return output.Length != 0 ? "Package Imports:\r\n" + output + " *" : string.Empty;
+            throw new NotImplementedException();
         }
 
+        [Obsolete]
         public string GetStats()
         {
-            var output = string.Empty;
-
-            if (Constants != null && Constants.Count > 0)
-                output += " *\tConstants:" + Constants.Count + "\r\n";
-
-            if (Enums != null && Enums.Count > 0)
-                output += " *\tEnums:" + Enums.Count + "\r\n";
-
-            if (Structs != null && Structs.Count > 0)
-                output += " *\tStructs:" + Structs.Count + "\r\n";
-
-            if (Variables != null && Variables.Count > 0)
-                output += " *\tProperties:" + Variables.Count + "\r\n";
-
-            if (Functions != null && Functions.Count > 0)
-                output += " *\tFunctions:" + Functions.Count + "\r\n";
-
-            if (States != null && States.Count > 0)
-                output += " *\tStates:" + States.Count + "\r\n";
-
-            return output.Length != 0 ? "Stats:\r\n" + output + " *" : string.Empty;
+            throw new NotImplementedException();
         }
 
         protected override string FormatHeader()
@@ -402,24 +358,12 @@ private string FormatFlags()
                 output += $"\r\n\tdllbind({DLLBindName})";
             }
 
-            if (ClassDependencies != null)
+            if (ClassDependencies != null) foreach (var dependency in ClassDependencies)
             {
-                var dependsOn = new List<int>();
-                foreach (var dependency in ClassDependencies)
+                var obj = dependency.Class;
+                if (obj != null && (int)obj > (int)this && obj != Super)
                 {
-                    if (dependsOn.Exists(dep => dep == dependency.Class))
-                    {
-                        continue;
-                    }
-
-                    var obj = (UClass)GetIndexObject(dependency.Class);
-                    // Only exports and those who are further than this class
-                    if (obj != null && (int)obj > (int)this)
-                    {
-                        output += $"\r\n\tdependson({obj.Name})";
-                    }
-
-                    dependsOn.Add(dependency.Class);
+                    output += $"\r\n\tdependson({obj.Name})";
                 }
             }
 

From 0ade4b0ac9561ae8a19495fd695083e320875101 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Fri, 5 Aug 2022 19:47:24 +0200
Subject: [PATCH 10/11] Support DNF's UClass format #49 (this makes it possible
 to decompile the DefaultProperties).

---
 src/Core/Classes/UClass.cs  | 27 +++++++++++++++++++++++++++
 src/Core/Classes/UStruct.cs |  4 +++-
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/src/Core/Classes/UClass.cs b/src/Core/Classes/UClass.cs
index 70bdfd7..3074039 100644
--- a/src/Core/Classes/UClass.cs
+++ b/src/Core/Classes/UClass.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using UELib.Annotations;
@@ -197,7 +198,32 @@ protected override void Deserialize()
                 Record(nameof(Within), Within);
                 ConfigName = _Buffer.ReadNameReference();
                 Record(nameof(ConfigName), ConfigName);
+#if DNF
+                if (_Buffer.Package.Build == UnrealPackage.GameBuild.BuildName.DNF &&
+                    _Buffer.Version >= 102)
+                {
+                    DeserializeHideCategories();
+                    if (_Buffer.Version >= 137)
+                    {
+                        _Buffer.ReadArray(out UArray<string> dnfStringArray);
+                        Record(nameof(dnfStringArray), dnfStringArray);
+                    }
 
+                    if (_Buffer.Version >= 113)
+                    {
+                        // Unknown purpose, used to set a global variable to 0 (GIsATablesInitialized_exref) if it reads 0.
+                        bool dnfBool = _Buffer.ReadBool();
+                        Record(nameof(dnfBool), dnfBool);
+                        
+                        // FBitArray data, not sure if this behavior is correct, always 0.
+                        int dnfBitArrayLength = _Buffer.ReadInt32();
+                        _Buffer.Skip(dnfBitArrayLength);
+                        Record(nameof(dnfBitArrayLength), dnfBitArrayLength);
+                    }
+
+                    goto scriptProperties;
+                }
+#endif
                 const int vHideCategoriesOldOrder = 539;
                 bool isHideCategoriesOldOrder = _Buffer.Version <= vHideCategoriesOldOrder
 #if TERA
@@ -477,6 +503,7 @@ protected override void Deserialize()
                 }
             }
 #endif
+        scriptProperties:
             // In later UE3 builds, defaultproperties are stored in separated objects named DEFAULT_namehere,
             // TODO: Corrigate Version
             if (_Buffer.Version >= 322)
diff --git a/src/Core/Classes/UStruct.cs b/src/Core/Classes/UStruct.cs
index d95ff63..e33229c 100644
--- a/src/Core/Classes/UStruct.cs
+++ b/src/Core/Classes/UStruct.cs
@@ -118,7 +118,9 @@ protected override void Deserialize()
                 if (_Buffer.LicenseeVersion >= 2)
                 {
                     // Bool?
-                    _Buffer.ReadByte();
+                    byte dnfByte = _Buffer.ReadByte();
+                    Record(nameof(dnfByte), dnfByte);
+                    
                     var dnfName = _Buffer.ReadNameReference();
                     Record(nameof(dnfName), dnfName);
                 }

From a63faaf81db118d89dda0e8a6853e4b4a8cce415 Mon Sep 17 00:00:00 2001
From: Eliot <contact@eliotvu.com>
Date: Fri, 5 Aug 2022 22:16:11 +0200
Subject: [PATCH 11/11] List "Duke Nukem Forever (2011)" as compatible.

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index c220eb0..c49b1ac 100644
--- a/README.md
+++ b/README.md
@@ -68,6 +68,7 @@ This is a table of games that are confirmed to be compatible with the current st
 | Bioshock 2 | Vengeance | 143/059 | |
 | Unreal Championship 2: Liandri Conflict | 3323 | 151/002 | (Third-party) <https://forums.beyondunreal.com/threads/unreal-championship-2-script-decompiler-release.206036/> |
 | The Chronicles of Spellborn | Unknown | 159/029 | |
+| Duke Nukem Forever (2011) | Unknown | 156/036 | [Extraction is required](https://github.com/DaZombieKiller/MegaPackageExtractor) |
 |     |     |     |     |
 |     |     |     |     |
 | Roboblitz | 2306 | 369/006 |     |