From 4f4bef374ccc3a50f7a14ee894a35e091383bb45 Mon Sep 17 00:00:00 2001
From: wghost <wghost81@gmail.com>
Date: Mon, 23 Mar 2015 12:56:51 +0400
Subject: [PATCH] Pseudo-code decompiler and new [@] command

---
 HexToPseudoCode.cpp          |  85 ++++
 ModScript.cpp                |  88 +++-
 ModScript.h                  |   1 +
 UENativeTablesReader.cpp     |  69 +++
 UPKInfo.h                    |   6 +-
 UPKUtils.cbp                 |  76 ++-
 UPKUtils.cpp                 |   1 +
 UToken.cpp                   | 705 +++++++++++++++++++++++++++
 UToken.h                     | 920 +++++++++++++++++++++++++++++++++++
 UTokenFactory.cpp            | 361 ++++++++++++++
 UTokenFactory.h              |  14 +
 build/CMakeLists.txt         |   4 +
 doc/PatchUPK_Mod_Example.txt |  54 +-
 doc/PatchUPK_Readme.txt      | 222 ++++-----
 doc/UPKUtils_Readme.txt      |  80 ++-
 15 files changed, 2500 insertions(+), 186 deletions(-)
 create mode 100644 HexToPseudoCode.cpp
 create mode 100644 UENativeTablesReader.cpp
 create mode 100644 UToken.cpp
 create mode 100644 UToken.h
 create mode 100644 UTokenFactory.cpp
 create mode 100644 UTokenFactory.h

diff --git a/HexToPseudoCode.cpp b/HexToPseudoCode.cpp
new file mode 100644
index 0000000..552bd0b
--- /dev/null
+++ b/HexToPseudoCode.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <sstream>
+
+#include "UPKUtils.h"
+#include "UToken.h"
+
+using namespace std;
+
+string GetFilename(string str)
+{
+    unsigned found = str.find_last_of("/\\");
+    return str.substr(found + 1);
+}
+
+int main(int argN, char* argV[])
+{
+    //cout << "HexToPseudoCode" << endl;
+
+    if (argN < 3 || argN > 4)
+    {
+        cerr << "Usage: HexToPseudoCode UnpackedResourceFile.upk ObjectName [/d]" << endl;
+        return 1;
+    }
+
+    UPKUtils package(argV[1]);
+
+    UPKReadErrors err = package.GetError();
+
+    if (err != UPKReadErrors::NoErrors)
+    {
+        cerr << "Error reading package:\n" << FormatReadErrors(err);
+        if (package.IsCompressed())
+            cerr << "Compression flags:\n" << FormatCompressionFlags(package.GetCompressionFlags());
+        return 1;
+    }
+
+    string NameToFind = argV[2];
+
+    //cout << "Object to find: " << NameToFind << endl;
+
+    UObjectReference ObjRef = package.FindObject(NameToFind, false);
+
+    if (ObjRef == 0)
+    {
+        cerr << "Unable to find object entry by name " << NameToFind << endl;
+        return 1;
+    }
+    if (ObjRef > 0 && argN == 4 && string(argV[3]) == "/d")
+    {
+        package.SaveExportData((uint32_t)ObjRef);
+    }
+    if (ObjRef > 0)
+    {
+        //cout << "Found Export Object:\n" << package.FormatExport(ObjRef, true);
+    }
+    else
+    {
+        //cout << "Found Import Object:\n" << package.FormatImport(-ObjRef, true);
+    }
+
+    if (ObjRef <= 0 || (package.GetExportEntry(ObjRef).Type != "Function" && package.GetExportEntry(ObjRef).Type != "State"))
+    {
+        cerr << "Object is not a Function nor a State, can not convert to pseudo-code!\n";
+        return 1;
+    }
+
+    //cout << "Attempting deserialization:\n";
+
+    vector<char> ObjData = package.GetExportData(ObjRef);
+    stringstream stream;
+    stream.write(ObjData.data(), ObjData.size());
+    size_t ScrPos = package.GetScriptRelOffset(ObjRef);
+    stream.seekg(ScrPos);
+
+    UScriptCode ScrCode;
+    string PseudoCode = ScrCode.Deserialize(stream, package);
+    cout << "//This script was generated by HexToPseudoCode decompiler for use with PatchUPK/PatcherGUI tool\n"
+         << "UPK_FILE = " << GetFilename(argV[1]) << "\n"
+         << "OBJECT = " << NameToFind << " : AUTO\n"
+         << "[REPLACEMENT_CODE]\n"
+         << PseudoCode;
+
+    return 0;
+}
+
diff --git a/ModScript.cpp b/ModScript.cpp
index 79bb2de..9545ee1 100644
--- a/ModScript.cpp
+++ b/ModScript.cpp
@@ -3,6 +3,7 @@
 #include <cstring>
 #include <cctype>
 #include <algorithm>
+#include <stack>
 
 void ModScript::SetExecutors()
 {
@@ -1856,6 +1857,11 @@ std::string GetWord(std::istream& in)
         }
         return word;
     }
+    /// extract marker
+    if (ch == '(' || ch == ')')
+    {
+        return word;
+    }
     /// extract HEX
     if (isxdigit(ch))
     {
@@ -1900,6 +1906,7 @@ std::string ModScript::ParseScript(std::string ScriptData, unsigned* ScriptMemSi
     std::ostringstream ScriptHEX;
     std::istringstream WorkingData(ScriptData);
     std::map<std::string, uint16_t> Labels;
+    std::stack<std::string> MarkerLabels;
     unsigned ScriptMemSize = 0, MemSize = 0;
     bool needSecondPass = false;
     unsigned numPasses = 0;
@@ -1912,6 +1919,12 @@ std::string ModScript::ParseScript(std::string ScriptData, unsigned* ScriptMemSi
             WorkingData.clear();
             ScriptHEX.str("");
             ScriptHEX.clear();
+            if (MarkerLabels.size() != 0)
+            {
+                *ErrorMessages << "Unresolved marker(s) found!" << std::endl;
+                SetBad();
+                return std::string("");
+            }
         }
         while (!WorkingData.eof())
         {
@@ -1951,15 +1964,41 @@ std::string ModScript::ParseScript(std::string ScriptData, unsigned* ScriptMemSi
                 Command = EatWhite(Command); /// remove white-spaces
                 if (Command[0] == '@') /// label reference
                 {
-                    if (Labels.count(Command.substr(1)) != 0) /// found reference
+                    if (Command.length() == 1) /// [@] - auto-calculate memory size
                     {
-                        uint16_t LabelPos = Labels[Command.substr(1)];
-                        ScriptHEX << MakeTextBlock(reinterpret_cast<char*>(&LabelPos), 2);
+                        if (numPasses == 0) /// first pass - create label
+                        {
+                            std::string autoLabel = "__automemsize__" + FormatHEX(ScriptMemSize);
+                            if (Labels.count(autoLabel) != 0)
+                            {
+                                *ErrorMessages << "Internal error! Duplicated auto-label: " << autoLabel << std::endl;
+                                SetBad();
+                                return std::string("");
+                            }
+                            Labels[autoLabel] = 0; /// init new label
+                            MarkerLabels.push(autoLabel); /// keep track of unresolved labels
+                            needSecondPass = true; /// request second pass
+                            ScriptHEX << "[@" << autoLabel << "] "; /// put auto-generated label back into the stream
+                        }
+                        else
+                        {
+                            *ErrorMessages << "Internal error! Unresolved command: " << NextWord << std::endl;
+                            SetBad();
+                            return std::string("");
+                        }
                     }
-                    else
+                    else /// [@label_name] - resolve named labels
                     {
-                        ScriptHEX << NextWord << " ";
-                        needSecondPass = true;
+                        if (Labels.count(Command.substr(1)) != 0) /// found reference
+                        {
+                            uint16_t LabelPos = Labels[Command.substr(1)];
+                            ScriptHEX << MakeTextBlock(reinterpret_cast<char*>(&LabelPos), 2);
+                        }
+                        else
+                        {
+                            ScriptHEX << NextWord << " ";
+                            needSecondPass = true;
+                        }
                     }
                     if (numPasses == 0)
                         ScriptMemSize += 2;
@@ -1976,6 +2015,36 @@ std::string ModScript::ParseScript(std::string ScriptData, unsigned* ScriptMemSi
                         Labels[Command.substr(1)] = ScriptMemSize;
                 }
             }
+            else if(IsMarker(NextWord)) /// resolve memory size markers '(' and ')'
+            {
+                if (numPasses != 0) /// should not be here at the second pass
+                {
+                    *ErrorMessages << "Internal error! Unresolved marker: " << NextWord << std::endl;
+                    SetBad();
+                    return std::string("");
+                }
+                if (NextWord == "(") /// start position
+                {
+                    if (MarkerLabels.size() == 0 || Labels[MarkerLabels.top()] != 0)
+                    {
+                        *ErrorMessages << "Bad marker: " << NextWord << std::endl;
+                        SetBad();
+                        return std::string("");
+                    }
+                    Labels[MarkerLabels.top()] = ScriptMemSize;
+                }
+                else /// end position
+                {
+                    if (MarkerLabels.size() == 0 || Labels[MarkerLabels.top()] == 0)
+                    {
+                        *ErrorMessages << "Bad marker: " << NextWord << std::endl;
+                        SetBad();
+                        return std::string("");
+                    }
+                    Labels[MarkerLabels.top()] = ScriptMemSize - Labels[MarkerLabels.top()];
+                    MarkerLabels.pop(); /// close the current marker
+                }
+            }
             else
             {
                 *ErrorMessages << "Bad token: " << NextWord << std::endl;
@@ -2013,6 +2082,13 @@ bool ModScript::IsCommand(std::string word)
     return (word.front() == '[' && word.back() == ']');
 }
 
+bool ModScript::IsMarker(std::string word)
+{
+    if (word.length() != 1) /// one symbol '(' or ')'
+        return false;
+    return (word.front() == '(' || word.back() == ')');
+}
+
 std::string ModScript::TokenToHEX(std::string Token, unsigned* MemSizeRef)
 {
     std::string Code = Token.substr(1, Token.length()-2); /// remove <>
diff --git a/ModScript.h b/ModScript.h
index df7246e..2f92632 100644
--- a/ModScript.h
+++ b/ModScript.h
@@ -145,6 +145,7 @@ class ModScript
     bool IsHEX(std::string word);
     bool IsToken(std::string word);
     bool IsCommand(std::string word);
+    bool IsMarker(std::string word);
     std::string TokenToHEX(std::string Token, unsigned* MemSizeRef = nullptr);
 };
 
diff --git a/UENativeTablesReader.cpp b/UENativeTablesReader.cpp
new file mode 100644
index 0000000..2e2244f
--- /dev/null
+++ b/UENativeTablesReader.cpp
@@ -0,0 +1,69 @@
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+#include <string>
+
+using namespace std;
+
+#define MAGIC (uint32_t)747443441
+
+int main(int argN, char* argV[])
+{
+    cout << "UENativeTablesReader" << endl;
+
+    if (argN != 2)
+    {
+        cerr << "Usage: UENativeTablesReader NativeTable.NTL" << endl;
+        return 1;
+    }
+
+    ifstream table(argV[1], ios::binary);
+    if (!table.is_open())
+    {
+        cerr << "Can't open " << argV[1] << endl;
+        return 1;
+    }
+
+    uint32_t magic;
+    table.read(reinterpret_cast<char*>(&magic), sizeof(magic));
+    if (magic != MAGIC)
+    {
+        cerr << "Input file is not a NTL file!\n";
+        return 1;
+    }
+
+    uint32_t num;
+    table.read(reinterpret_cast<char*>(&num), sizeof(num));
+    if (num < 0 || num > 0xFFF)
+    {
+        cerr << "Input file is not a NTL file!\n";
+        return 1;
+    }
+
+    cout << "Num = " << num << endl;
+
+    cout << "HEX\tName\t\t\t\tOpPrec\tType\tToken\n";
+
+    for (unsigned i = 0; i < num; ++i)
+    {
+        uint8_t NameLen;
+        string Name;
+        uint8_t OperPrecedence;
+        uint8_t Type;
+        uint32_t ByteToken;
+        char ch[255];
+
+        table.read(reinterpret_cast<char*>(&NameLen), sizeof(NameLen));
+        table.read(ch, NameLen);
+        Name = string(ch, NameLen);
+        table.read(reinterpret_cast<char*>(&OperPrecedence), sizeof(OperPrecedence));
+        table.read(reinterpret_cast<char*>(&Type), sizeof(Type));
+        table.read(reinterpret_cast<char*>(&ByteToken), sizeof(ByteToken));
+
+        cout << "0x" << setfill('0') << setw(2) << hex << ByteToken << "\t" << Name
+             << "\t\t\t\t"
+             << dec << (int)OperPrecedence << "\t" << (int)Type << "\t" << ByteToken << endl;
+    }
+
+    return 0;
+}
diff --git a/UPKInfo.h b/UPKInfo.h
index df5fc87..6322a3c 100644
--- a/UPKInfo.h
+++ b/UPKInfo.h
@@ -160,7 +160,7 @@ class UPKInfo
 {
     public:
         /// constructors
-        UPKInfo(): Summary(), NoneIdx(0), ReadError(UPKReadErrors::NoErrors), Compressed(false), CompressedChunk(false) {};
+        UPKInfo(): Summary(), NoneIdx(0), ReadError(UPKReadErrors::NoErrors), Compressed(false), CompressedChunk(false), LastAccessedExportObjIdx(0) {};
         UPKInfo(std::istream& stream);
         /// destructor
         ~UPKInfo() {};
@@ -187,7 +187,8 @@ class UPKInfo
         bool IsCompressed() { return Compressed; }
         bool IsFullyCompressed() { return (Compressed && CompressedChunk); }
         UPKReadErrors GetError() { return ReadError; }
-        uint32_t GetCompressionFlags() { return Summary.CompressionFlags; }
+        uint32_t GetCompressionFlags() { return Summary.CompressionFlags; }
+        UObjectReference GetLastAccessedExportObjIdx() { return LastAccessedExportObjIdx; }
         /// format header to text string
         std::string FormatCompressedHeader();
         std::string FormatSummary();
@@ -208,6 +209,7 @@ class UPKInfo
         bool Compressed;
         bool CompressedChunk;
         FCompressedChunkHeader CompressedHeader;
+        UObjectReference LastAccessedExportObjIdx;
 };
 
 /// helper functions
diff --git a/UPKUtils.cbp b/UPKUtils.cbp
index 76ad228..c60bd9c 100644
--- a/UPKUtils.cbp
+++ b/UPKUtils.cbp
@@ -76,6 +76,22 @@
 				<Option compiler="gcc" />
 				<Option parameters="XComStrategyGame.upk" />
 			</Target>
+			<Target title="UENativeTablesReader">
+				<Option output="bin/UENativeTablesReader" prefix_auto="1" extension_auto="1" />
+				<Option working_dir="bin/" />
+				<Option object_output="obj/UENativeTablesReader" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Option parameters="XComStrategyGame.upk" />
+			</Target>
+			<Target title="HexToPseudoCode">
+				<Option output="bin/HexToPseudoCode" prefix_auto="1" extension_auto="1" />
+				<Option working_dir="bin/" />
+				<Option object_output="obj/HexToPseudoCode" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Option parameters="XComStrategyGame.upk" />
+			</Target>
 		</Build>
 		<Compiler>
 			<Add option="-O2" />
@@ -101,6 +117,9 @@
 		<Unit filename="FindObjectEntry.cpp">
 			<Option target="FindObjectEntry" />
 		</Unit>
+		<Unit filename="HexToPseudoCode.cpp">
+			<Option target="HexToPseudoCode" />
+		</Unit>
 		<Unit filename="ModParser.cpp">
 			<Option target="PatchUPK" />
 		</Unit>
@@ -119,44 +138,95 @@
 		<Unit filename="PatchUPK.cpp">
 			<Option target="PatchUPK" />
 		</Unit>
-		<Unit filename="UFlags.h" />
+		<Unit filename="UENativeTablesReader.cpp">
+			<Option target="UENativeTablesReader" />
+		</Unit>
+		<Unit filename="UFlags.h">
+			<Option target="ExtractNameLists" />
+			<Option target="FindObjectEntry" />
+			<Option target="PatchUPK" />
+			<Option target="MoveExpandFunction" />
+			<Option target="FindObjectByOffset" />
+			<Option target="DeserializeAll" />
+			<Option target="CompareUPK" />
+			<Option target="DecompressLZO" />
+			<Option target="HexToPseudoCode" />
+		</Unit>
 		<Unit filename="UObject.cpp">
 			<Option target="FindObjectEntry" />
 			<Option target="PatchUPK" />
 			<Option target="MoveExpandFunction" />
 			<Option target="DeserializeAll" />
+			<Option target="HexToPseudoCode" />
 		</Unit>
 		<Unit filename="UObject.h">
 			<Option target="FindObjectEntry" />
 			<Option target="PatchUPK" />
 			<Option target="MoveExpandFunction" />
 			<Option target="DeserializeAll" />
+			<Option target="HexToPseudoCode" />
 		</Unit>
 		<Unit filename="UObjectFactory.cpp">
 			<Option target="FindObjectEntry" />
 			<Option target="PatchUPK" />
 			<Option target="MoveExpandFunction" />
 			<Option target="DeserializeAll" />
+			<Option target="HexToPseudoCode" />
 		</Unit>
 		<Unit filename="UObjectFactory.h">
 			<Option target="FindObjectEntry" />
 			<Option target="PatchUPK" />
 			<Option target="MoveExpandFunction" />
 			<Option target="DeserializeAll" />
+			<Option target="HexToPseudoCode" />
+		</Unit>
+		<Unit filename="UPKInfo.cpp">
+			<Option target="ExtractNameLists" />
+			<Option target="FindObjectEntry" />
+			<Option target="PatchUPK" />
+			<Option target="MoveExpandFunction" />
+			<Option target="FindObjectByOffset" />
+			<Option target="DeserializeAll" />
+			<Option target="CompareUPK" />
+			<Option target="DecompressLZO" />
+			<Option target="HexToPseudoCode" />
+		</Unit>
+		<Unit filename="UPKInfo.h">
+			<Option target="ExtractNameLists" />
+			<Option target="FindObjectEntry" />
+			<Option target="PatchUPK" />
+			<Option target="MoveExpandFunction" />
+			<Option target="FindObjectByOffset" />
+			<Option target="DeserializeAll" />
+			<Option target="CompareUPK" />
+			<Option target="DecompressLZO" />
+			<Option target="HexToPseudoCode" />
 		</Unit>
-		<Unit filename="UPKInfo.cpp" />
-		<Unit filename="UPKInfo.h" />
 		<Unit filename="UPKUtils.cpp">
 			<Option target="PatchUPK" />
 			<Option target="MoveExpandFunction" />
 			<Option target="FindObjectEntry" />
 			<Option target="DeserializeAll" />
+			<Option target="HexToPseudoCode" />
 		</Unit>
 		<Unit filename="UPKUtils.h">
 			<Option target="PatchUPK" />
 			<Option target="MoveExpandFunction" />
 			<Option target="FindObjectEntry" />
 			<Option target="DeserializeAll" />
+			<Option target="HexToPseudoCode" />
+		</Unit>
+		<Unit filename="UToken.cpp">
+			<Option target="HexToPseudoCode" />
+		</Unit>
+		<Unit filename="UToken.h">
+			<Option target="HexToPseudoCode" />
+		</Unit>
+		<Unit filename="UTokenFactory.cpp">
+			<Option target="HexToPseudoCode" />
+		</Unit>
+		<Unit filename="UTokenFactory.h">
+			<Option target="HexToPseudoCode" />
 		</Unit>
 		<Unit filename="lzoconf.h">
 			<Option target="DecompressLZO" />
diff --git a/UPKUtils.cpp b/UPKUtils.cpp
index 8dee0b4..09fd93e 100644
--- a/UPKUtils.cpp
+++ b/UPKUtils.cpp
@@ -49,6 +49,7 @@ std::vector<char> UPKUtils::GetExportData(uint32_t idx)
     data.resize(ExportTable[idx].SerialSize);
     UPKFile.seekg(ExportTable[idx].SerialOffset);
     UPKFile.read(data.data(), data.size());
+    LastAccessedExportObjIdx = idx;
     return data;
 }
 
diff --git a/UToken.cpp b/UToken.cpp
new file mode 100644
index 0000000..618703f
--- /dev/null
+++ b/UToken.cpp
@@ -0,0 +1,705 @@
+#include <sstream>
+#include <map>
+#include "UToken.h"
+#include "UTokenFactory.h"
+
+std::string MakeIndents(int indents)
+{
+    if (indents <= 0)
+    {
+        return "";
+    }
+    return std::string(indents, '\t');
+}
+
+int CountIndents(std::string str)
+{
+    size_t pos = str.find('\t');
+    if (pos == std::string::npos)
+    {
+        return 0;
+    }
+    return str.rfind('\t') - pos + 1;
+}
+
+std::string CopyPositionsComment(std::string str)
+{
+    size_t pos = str.find("/*");
+    if (pos == std::string::npos)
+    {
+        return "";
+    }
+    size_t len = str.rfind("*/") - pos + 3;
+    return str.substr(pos, len);
+}
+
+std::string UScriptCode::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::map<uint16_t, std::string> ExprMap;
+    std::map<uint16_t, int> JumpMap;
+    int numIndents = 0;
+    while (stream.good())
+    {
+        UScriptExpression ScrExpr;
+        std::string ExprResult = ScrExpr.Deserialize(stream, info);
+        if (JumpMap.count(MemorySize) > 0) /// reached jump label - remove indentation(s)
+        {
+            numIndents -= JumpMap[MemorySize];
+            JumpMap[MemorySize] = 0;
+        }
+        ExprMap[MemorySize] = "/*(" + FormatHEX(MemorySize) + "/" + FormatHEX(SerialSize) + ")*/ "
+                            + MakeIndents(numIndents) + ExprResult + "\n";
+        if (ScrExpr.IsJump() && ScrExpr.GetJumpOffset() > MemorySize && ScrExpr.GetJumpOffset() != 0xFFFF) /// add indentation
+        {
+            numIndents += ScrExpr.GetType() != UToken::Jump;
+            JumpMap[ScrExpr.GetJumpOffset()] += ScrExpr.GetType() != UToken::Jump;
+        }
+        SerialSize += ScrExpr.GetSerialSize();
+        MemorySize += ScrExpr.GetMemorySize();
+        if (ScrExpr.IsEOS()) /// end of script
+        {
+            break;
+        }
+    }
+    for (std::map<uint16_t, int>::iterator it = JumpMap.begin(); it != JumpMap.end(); ++it)
+    {
+        if (it->first != 0xFFFF)
+        {
+            ExprMap[it->first] = CopyPositionsComment(ExprMap[it->first])
+            + MakeIndents(CountIndents(ExprMap[it->first]))
+            + "[#label_" + FormatHEX(it->first) + "]\n" + ExprMap[it->first];
+        }
+    }
+    std::stringstream result;
+    for (std::map<uint16_t, std::string>::iterator it = ExprMap.begin(); it != ExprMap.end(); ++it)
+    {
+        result << it->second;
+    }
+    return result.str();
+}
+
+std::string UScriptExpression::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    UScriptToken* ScrToken;
+    Type = (UToken)stream.get();
+    if (Type > UToken::NativeFunctionF)
+    {
+        stream.putback((uint8_t)Type);
+        Type = UToken::ExtendedNative;
+    }
+    ScrToken = UTokenFactory::Create(Type);
+    if (ScrToken == nullptr)
+    {
+        result << "Error! Unknown token: " << FormatHEX((uint8_t)Type) << "\n";
+        return result.str();
+    }
+    std::string TokenResult = ScrToken->Deserialize(stream, info);
+    result << TokenResult;
+    SerialSize += ScrToken->GetSerialSize();
+    MemorySize += ScrToken->GetMemorySize();
+    JumpOffset = ScrToken->GetJumpOffset();
+    if (Type == UToken::Switch)
+    {
+        JumpOffset = 0xFFFF;
+    }
+    delete ScrToken;
+    return result.str();
+}
+
+std::string UScriptToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 1;
+    MemorySize += 1;
+    return FormatType();
+}
+
+std::string UScriptToken::DeserializeObjRef(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 4;
+    MemorySize += 8;
+    return FormatObjRef(ReadObjRef(stream), info);
+}
+
+std::string UScriptToken::DeserializeNameIndex(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 8;
+    MemorySize += 8;
+    return FormatNameIndex(ReadNameIndex(stream), info);
+}
+
+std::string UScriptToken::DeserializeByte(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 1;
+    MemorySize += 1;
+    return FormatByte(ReadByte(stream));
+}
+
+std::string UScriptToken::DeserializeShort(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 2;
+    MemorySize += 2;
+    return FormatShort(ReadShort(stream));
+}
+
+std::string UScriptToken::DeserializeMemoryOffset(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 2;
+    MemorySize += 2;
+    JumpOffset = ReadShort(stream);
+    if (JumpOffset != 0xFFFF)
+    {
+        return FormatMemOffset(JumpOffset);
+    }
+    return FormatShort(JumpOffset);
+}
+
+std::string UScriptToken::DeserializeMemorySize(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 2;
+    MemorySize += 2;
+    return FormatMemSize(ReadShort(stream));
+}
+
+std::string UScriptToken::DeserializeInt(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 4;
+    MemorySize += 4;
+    return FormatInt(ReadInt(stream));
+}
+
+std::string UScriptToken::DeserializeUInt(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 4;
+    MemorySize += 4;
+    return FormatUInt(ReadUInt(stream));
+}
+
+std::string UScriptToken::DeserializeFloat(std::istream& stream, UPKInfo& info)
+{
+    SerialSize += 4;
+    MemorySize += 4;
+    return FormatFloat(ReadFloat(stream));
+}
+
+std::string UScriptToken::DeserializeString(std::istream& stream, UPKInfo& info)
+{
+    std::string Str;
+    getline(stream, Str, '\0');
+    SerialSize += Str.length() + 1;
+    MemorySize += Str.length() + 1;
+    return FormatString(Str);
+}
+
+std::string UScriptToken::DeserializeUniString(std::istream& stream, UPKInfo& info)
+{
+    /// stub!
+    return DeserializeString(stream, info);
+}
+
+std::string UScriptToken::DeserializeExpression(std::istream& stream, UPKInfo& info, int num)
+{
+    if (num == 0)
+    {
+        return "";
+    }
+    std::stringstream result;
+    int cnt = 0;
+    FoundSkip = false;
+    while (stream.good())
+    {
+        UScriptExpression ScrExpr;
+        result << ScrExpr.Deserialize(stream, info);
+        SerialSize += ScrExpr.GetSerialSize();
+        MemorySize += ScrExpr.GetMemorySize();
+        ++cnt;
+        if (ScrExpr.GetType() == UToken::Skip)
+        {
+            FoundSkip = true;
+        }
+        if ((num > 0 && cnt >= num) || (num < 0 && ScrExpr.IsEndFunction()))
+        {
+            break;
+        }
+    }
+    return result.str();
+}
+
+std::string UScriptToken::DeserializeFunctionCall(std::istream& stream, UPKInfo& info)
+{
+    std::string result = DeserializeExpression(stream, info, -1);
+    if (FoundSkip)
+    {
+        result += ") "; /// memory size marker
+        FoundSkip = false;
+    }
+    return result;
+}
+
+std::string UScriptToken::FormatType()
+{
+    return FormatHEX((char*)&Type, 1);
+}
+
+UObjectReference UScriptToken::ReadObjRef(std::istream& stream)
+{
+    UObjectReference ObjRef;
+    stream.read((char*)&ObjRef, 4);
+    return ObjRef;
+}
+
+std::string UScriptToken::FormatObjRef(UObjectReference ObjRef, UPKInfo& info)
+{
+    std::stringstream result;
+    if (ObjRef == 0)
+    {
+        result << "<NullRef> ";
+    }
+    else
+    {
+        if (ObjRef > 0)
+        {
+            if (info.GetExportEntry(ObjRef).Type == "Class")
+            {
+                result << "<Class." << info.GetExportEntry(ObjRef).FullName << "> ";
+            }
+            else
+            {
+                bool IsLocal = (info.GetLastAccessedExportObjIdx() == info.GetExportEntry(ObjRef).OwnerRef && info.GetExportEntry(ObjRef).OwnerRef != 0);
+                bool IsMember = (info.GetExportEntry(info.GetLastAccessedExportObjIdx()).OwnerRef == info.GetExportEntry(ObjRef).OwnerRef && info.GetExportEntry(ObjRef).OwnerRef != 0);
+                if (IsLocal)
+                {
+                    result << "<." << info.GetExportEntry(ObjRef).Name << "> ";
+                }
+                else if (IsMember)
+                {
+                    result << "<@" << info.GetExportEntry(ObjRef).Name << "> ";
+                }
+                else
+                {
+                    result << "<" << info.GetExportEntry(ObjRef).FullName << "> ";
+                }
+            }
+        }
+        else
+        {
+            result << "<" << info.GetImportEntry(-ObjRef).FullName << "> ";
+        }
+    }
+    return result.str();
+}
+
+uint8_t UScriptToken::ReadByte(std::istream& stream)
+{
+    uint8_t Byte;
+    stream.read((char*)&Byte, 1);
+    return Byte;
+}
+
+std::string UScriptToken::FormatByte(uint8_t Byte)
+{
+    return FormatHEX((char*)&Byte, 1);
+}
+
+uint16_t UScriptToken::ReadShort(std::istream& stream)
+{
+    uint16_t Short;
+    stream.read((char*)&Short, 2);
+    return Short;
+}
+
+std::string UScriptToken::FormatShort(uint16_t Short)
+{
+    return FormatHEX((char*)&Short, 2);
+}
+
+std::string UScriptToken::FormatMemOffset(uint16_t MemOff)
+{
+    return "[@label_" + FormatHEX(MemOff) + "] ";
+}
+
+std::string UScriptToken::FormatMemSize(uint16_t MemOff)
+{
+    return "[@] ";
+}
+
+UNameIndex UScriptToken::ReadNameIndex(std::istream& stream)
+{
+    UNameIndex NameIdx;
+    stream.read(reinterpret_cast<char*>(&NameIdx), sizeof(NameIdx));
+    return NameIdx;
+}
+
+std::string UScriptToken::FormatNameIndex(UNameIndex NameIdx, UPKInfo& info)
+{
+    return "<" + info.IndexToName(NameIdx) + "> ";
+}
+
+int32_t UScriptToken::ReadInt(std::istream& stream)
+{
+    int32_t Int;
+    stream.read((char*)&Int, 4);
+    return Int;
+}
+
+std::string UScriptToken::FormatInt(int32_t Int)
+{
+    std::stringstream ss;
+    ss << "<%i " << Int << "> ";
+    return ss.str();
+}
+
+uint32_t UScriptToken::ReadUInt(std::istream& stream)
+{
+    uint32_t UInt;
+    stream.read((char*)&UInt, 4);
+    return UInt;
+}
+
+std::string UScriptToken::FormatUInt(uint32_t UInt)
+{
+    std::stringstream ss;
+    ss << "<%u " << UInt << "> ";
+    return ss.str();
+}
+
+float UScriptToken::ReadFloat(std::istream& stream)
+{
+    float Flo;
+    stream.read((char*)&Flo, 4);
+    return Flo;
+}
+
+std::string UScriptToken::FormatFloat(float Flo)
+{
+    std::stringstream ss;
+    ss << "<%f " << Flo << "> ";
+    return ss.str();
+}
+
+std::string UScriptToken::FormatString(std::string Str)
+{
+    return "<%t \"" + Str + "\"> ";
+}
+
+std::string UExpressionToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info, Count);
+    return result.str();
+}
+
+std::string UObjRefToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeObjRef(stream, info);
+    return result.str();
+}
+
+std::string UNameIndexToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeNameIndex(stream, info);
+    return result.str();
+}
+
+std::string USwitchToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UObjRefToken::Deserialize(stream, info);
+    result << DeserializeByte(stream, info);
+    result << DeserializeExpression(stream, info);
+    return result.str();
+}
+
+std::string UJumpToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeMemoryOffset(stream, info);
+    return result.str();
+}
+
+std::string UJumpIfNotToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UJumpToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info);
+    return result.str();
+}
+
+std::string UAssertToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeShort(stream, info);
+    result << DeserializeByte(stream, info);
+    result << DeserializeExpression(stream, info);
+    return result.str();
+}
+
+std::string UCaseToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UJumpToken::Deserialize(stream, info);
+    if (JumpOffset != 0xFFFF)
+    {
+        result << DeserializeExpression(stream, info);
+    }
+    return result.str();
+}
+
+std::string ULabelTableToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    while (stream.good())
+    {
+        UNameIndex NameIdx = ReadNameIndex(stream);
+        result << FormatNameIndex(NameIdx, info);
+        SerialSize += 8;
+        MemorySize += 8;
+        result << FormatUInt(ReadUInt(stream));
+        SerialSize += 4;
+        MemorySize += 4;
+        if (info.IsNoneIdx(NameIdx))
+        {
+            break;
+        }
+    }
+    return result.str();
+}
+
+std::string UEatStringToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UObjRefToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info);
+    return result.str();
+}
+
+std::string UClassContextToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info);
+    result << DeserializeMemorySize(stream, info);
+    result << DeserializeObjRef(stream, info);
+    result << DeserializeByte(stream, info);
+    result << "( "; /// memory size marker
+    result << DeserializeExpression(stream, info);
+    result << ") "; /// memory size marker
+    return result.str();
+}
+
+std::string USkipToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeMemorySize(stream, info);
+    result << "( "; /// memory size marker
+    return result.str();
+}
+
+std::string UVirtualFunctionToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeNameIndex(stream, info);
+    result << DeserializeFunctionCall(stream, info);
+    return result.str();
+}
+
+std::string UFinalFunctionToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeObjRef(stream, info);
+    result << DeserializeFunctionCall(stream, info);
+    return result.str();
+}
+
+std::string UIntConstToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeInt(stream, info);
+    return result.str();
+}
+
+std::string UFloatConstToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeFloat(stream, info);
+    return result.str();
+}
+
+std::string UStringConstToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeString(stream, info);
+    return result.str();
+}
+
+std::string URotatorConstToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeInt(stream, info) << DeserializeInt(stream, info) << DeserializeInt(stream, info);
+    return result.str();
+}
+
+std::string UVectorConstToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeFloat(stream, info) << DeserializeFloat(stream, info) << DeserializeFloat(stream, info);
+    return result.str();
+}
+
+std::string UByteConstToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeByte(stream, info);
+    return result.str();
+}
+
+std::string UIteratorToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info);
+    result << DeserializeMemoryOffset(stream, info);
+    return result.str();
+}
+
+std::string UStructMemberToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeObjRef(stream, info);
+    result << DeserializeObjRef(stream, info);
+    result << DeserializeByte(stream, info);
+    result << DeserializeByte(stream, info);
+    result << DeserializeExpression(stream, info);
+    return result.str();
+}
+
+std::string UPrimitiveCastToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeByte(stream, info);
+    result << DeserializeExpression(stream, info);
+    return result.str();
+}
+
+std::string UDebugInfoToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeInt(stream, info) << DeserializeInt(stream, info) << DeserializeInt(stream, info);
+    result << DeserializeByte(stream, info);
+    return result.str();
+}
+
+std::string UDelegateFunctionToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeByte(stream, info);
+    result << DeserializeObjRef(stream, info);
+    result << DeserializeNameIndex(stream, info);
+    result << DeserializeFunctionCall(stream, info);
+    return result.str();
+}
+
+std::string UDelegatePropertyToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeNameIndex(stream, info);
+    result << DeserializeObjRef(stream, info);
+    return result.str();
+}
+
+std::string UTernaryConditionToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info);
+    result << DeserializeMemorySize(stream, info);
+    result << "( "; /// memory size marker
+    result << DeserializeExpression(stream, info);
+    result << ") "; /// memory size marker
+    result << DeserializeMemorySize(stream, info);
+    result << "( "; /// memory size marker
+    result << DeserializeExpression(stream, info);
+    result << ") "; /// memory size marker
+    return result.str();
+}
+
+std::string UDynArrFindToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info);
+    result << DeserializeMemorySize(stream, info);
+    result << "( "; /// memory size marker
+    result << DeserializeExpression(stream, info, 2);
+    result << ") "; /// memory size marker
+    return result.str();
+}
+
+std::string UDynArrayFindStructToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info);
+    result << DeserializeMemorySize(stream, info);
+    result << "( "; /// memory size marker
+    result << DeserializeExpression(stream, info, 3);
+    result << ") "; /// memory size marker
+    return result.str();
+}
+
+std::string UDefaultParmValueToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeMemorySize(stream, info);
+    result << "( "; /// memory size marker
+    result << DeserializeExpression(stream, info, 2);
+    result << ") "; /// memory size marker
+    return result.str();
+}
+
+std::string UDynArrIteratorToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    result << UScriptToken::Deserialize(stream, info);
+    result << DeserializeExpression(stream, info, 2);
+    result << DeserializeByte(stream, info);
+    result << DeserializeExpression(stream, info);
+    result << DeserializeMemoryOffset(stream, info);
+    return result.str();
+}
+
+std::string UNativeFunctionToken::Deserialize(std::istream& stream, UPKInfo& info)
+{
+    std::stringstream result;
+    if (Type != UToken::ExtendedNative)
+    {
+        result << UScriptToken::Deserialize(stream, info);
+    }
+    result << DeserializeByte(stream, info);
+    result << DeserializeFunctionCall(stream, info);
+    return result.str();
+}
+
diff --git a/UToken.h b/UToken.h
new file mode 100644
index 0000000..abe1564
--- /dev/null
+++ b/UToken.h
@@ -0,0 +1,920 @@
+#ifndef UTOKEN_H
+#define UTOKEN_H
+
+#include "UPKInfo.h"
+
+enum class UToken
+{
+	LocalVariable = 0,
+	InstanceVariable = 1,
+	DefaultVariable = 2,
+	StateVariable = 3,
+	Return = 4,
+	Switch = 5,
+	Jump = 6,
+	JumpIfNot = 7,
+	Stop = 8,
+	Assert = 9,
+	Case = 10,
+	Nothing = 11,
+	LabelTable = 12,
+	GotoLabel = 13,
+	EatString = 14,
+	Let = 15,
+	DynArrayElement = 16,
+	New = 17,
+	ClassContext = 18,
+	MetaCast = 19,
+	LetBool = 20,
+	EndParmValue = 21,
+	EndFunctionParms = 22,
+	Self = 23,
+	Skip = 24,
+	Context = 25,
+	ArrayElement = 26,
+	VirtualFunction = 27,
+	FinalFunction = 28,
+	IntConst = 29,
+	FloatConst = 30,
+	StringConst = 31,
+	ObjectConst = 32,
+	NameConst = 33,
+	RotatorConst = 34,
+	VectorConst = 35,
+	ByteConst = 36,
+	IntZero = 37,
+	IntOne = 38,
+	True = 39,
+	False = 40,
+	NativeParm = 41,
+	NoObject = 42,
+	UnknownDeprecated = 43,
+	IntConstByte = 44,
+	BoolVariable = 45,
+	DynamicCast = 46,
+	Iterator = 47,
+	IteratorPop = 48,
+	IteratorNext = 49,
+	StructCmpEq = 50,
+	StructCmpNe = 51,
+	UniStringConst = 52,
+	StructMember = 53,
+	DynArrayLen = 54,
+	GlobalFunction = 55,
+	PrimitiveCast = 56,
+	DynArrayInsert = 57,
+	ReturnNothing = 58,
+	DelegateCmpEq = 59,
+	DelegateCmpNe = 60,
+	DelegateFunctionCmpEq = 61,
+	DelegateFunctionCmpNE = 62,
+	NoDelegate = 63,
+	DynArrayRemove = 64,
+	DebugInfo = 65,
+	DelegateFunction = 66,
+	DelegateProperty = 67,
+	LetDelegate = 68,
+	TernaryCondition = 69,
+	DynArrFind = 70,
+	DynArrayFindStruct = 71,
+	OutVariable = 72,
+	DefaultParmValue = 73,
+	NoParm = 74,
+	InstanceDelegate = 75,
+	UnknownDynamicVariable1 = 76,
+	UnknownDynamicVariable2 = 77,
+	UnknownDynamicVariable3 = 78,
+	UnknownDynamicVariable4 = 79,
+	UnknownDynamicVariable5 = 80,
+	InterfaceContext = 81,
+	InterfaceCast = 82,
+	EndOfScript = 83,
+	DynArrAdd = 84,
+	DynArrAddItem = 85,
+	DynArrRemoveItem = 86,
+	DynArrInsertItem = 87,
+	DynArrIterator = 88,
+	DynArrSort = 89,
+	UnknownFilterEditorOnly1 = 90,
+	UnknownFilterEditorOnly2 = 91,
+	UnknownFilterEditorOnly3 = 92,
+	UnknownFilterEditorOnly4 = 93,
+	UnknownFilterEditorOnly5 = 94,
+	UnknownFilterEditorOnly6 = 95,
+	ExtendedNative = 96,
+	NativeFunction1 = 97,
+	NativeFunction2 = 98,
+	NativeFunction3 = 99,
+	NativeFunction4 = 100,
+	NativeFunction5 = 101,
+	NativeFunction6 = 102,
+	NativeFunction7 = 103,
+	NativeFunction8 = 104,
+	NativeFunction9 = 105,
+	NativeFunctionA = 106,
+	NativeFunctionB = 107,
+	NativeFunctionC = 108,
+	NativeFunctionD = 109,
+	NativeFunctionE = 110,
+	NativeFunctionF = 111
+};
+
+enum class UCastToken
+{
+	InterfaceToBool = 54,
+	InterfaceToString = 55,
+	InterfaceToObject = 56,
+	RotatorToVector = 57,
+	ByteToInt = 58,
+	ByteToBool = 59,
+	ByteToFloat = 60,
+	IntToByte = 61,
+	IntToBool = 62,
+	IntToFloat = 63,
+	BoolToByte = 64,
+	BoolToInt = 65,
+	BoolToFloat = 66,
+	FloatToByte = 67,
+	FloatToInt = 68,
+	FloatToBool = 69,
+	ObjectToInterface = 70,
+	ObjectToBool = 71,
+	NameToBool = 72,
+	StringToByte = 73,
+	StringToInt = 74,
+	StringToBool = 75,
+	StringToFloat = 76,
+	StringToVector = 77,
+	StringToRotator = 78,
+	VectorToBool = 79,
+	VectorToRotator = 80,
+	RotatorToBool = 81,
+	ByteToString = 82,
+	IntToString = 83,
+	BoolToString = 84,
+	FloatToString = 85,
+	ObjectToString = 86,
+	NameToString = 87,
+	VectorToString = 88,
+	RotatorToString = 89,
+	DelegateToString = 90,
+	StringToName = 96
+};
+
+class UScriptBase
+{
+public:
+    UScriptBase(): Type(UToken(0)), SerialSize(0), MemorySize(0), JumpOffset(0) {}
+    virtual ~UScriptBase() {}
+    virtual std::string Deserialize(std::istream& stream, UPKInfo& info) = 0;
+    uint32_t GetSerialSize() { return SerialSize; }
+    uint32_t GetMemorySize() { return MemorySize; }
+    uint16_t GetJumpOffset() { return JumpOffset; }
+protected:
+    UToken Type;
+    uint16_t SerialSize;
+    uint16_t MemorySize;
+    uint16_t JumpOffset;
+};
+
+class UScriptCode : public UScriptBase
+{
+public:
+    UScriptCode() {}
+    ~UScriptCode() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UScriptExpression : public UScriptBase
+{
+public:
+    UScriptExpression() {}
+    ~UScriptExpression() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+    UToken GetType() { return Type; }
+    bool IsEOS() { return (Type == UToken::EndOfScript); }
+    bool IsEndParm() { return (Type == UToken::EndParmValue); }
+    bool IsEndFunction() { return (Type == UToken::EndFunctionParms); }
+    bool IsJump() { return (Type == UToken::Jump || Type == UToken::JumpIfNot || Type == UToken::Case || Type == UToken::Iterator || Type == UToken::DynArrIterator); }
+};
+
+class UScriptToken : public UScriptBase
+{
+public:
+    UScriptToken(): FoundSkip(false) {}
+    virtual ~UScriptToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+    std::string DeserializeObjRef(std::istream& stream, UPKInfo& info);
+    std::string DeserializeNameIndex(std::istream& stream, UPKInfo& info);
+    std::string DeserializeByte(std::istream& stream, UPKInfo& info);
+    std::string DeserializeShort(std::istream& stream, UPKInfo& info);
+    std::string DeserializeMemoryOffset(std::istream& stream, UPKInfo& info);
+    std::string DeserializeMemorySize(std::istream& stream, UPKInfo& info);
+    std::string DeserializeInt(std::istream& stream, UPKInfo& info);
+    std::string DeserializeUInt(std::istream& stream, UPKInfo& info);
+    std::string DeserializeFloat(std::istream& stream, UPKInfo& info);
+    std::string DeserializeString(std::istream& stream, UPKInfo& info);
+    std::string DeserializeUniString(std::istream& stream, UPKInfo& info);
+    std::string DeserializeExpression(std::istream& stream, UPKInfo& info, int num = 1);
+    std::string DeserializeFunctionCall(std::istream& stream, UPKInfo& info);
+    bool HasSkipToken() { return FoundSkip; }
+protected:
+    /// helper functions
+    std::string FormatType();
+    UObjectReference ReadObjRef(std::istream& stream);
+    std::string FormatObjRef(UObjectReference ObjRef, UPKInfo& info);
+    uint8_t ReadByte(std::istream& stream);
+    std::string FormatByte(uint8_t Byte);
+    uint16_t ReadShort(std::istream& stream);
+    std::string FormatShort(uint16_t Short);
+    std::string FormatMemOffset(uint16_t MemOff);
+    std::string FormatMemSize(uint16_t MemOff);
+    UNameIndex ReadNameIndex(std::istream& stream);
+    std::string FormatNameIndex(UNameIndex NameIdx, UPKInfo& info);
+    int32_t ReadInt(std::istream& stream);
+    std::string FormatInt(int32_t Int);
+    uint32_t ReadUInt(std::istream& stream);
+    std::string FormatUInt(uint32_t UInt);
+    float ReadFloat(std::istream& stream);
+    std::string FormatFloat(float Flo);
+    std::string FormatString(std::string Str);
+
+    bool FoundSkip;
+};
+
+class UExpressionToken : public UScriptToken
+{
+public:
+    UExpressionToken() { Count = 1; }
+    virtual ~UExpressionToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+protected:
+    int Count;
+};
+
+class UObjRefToken : public UScriptToken
+{
+public:
+    UObjRefToken() {}
+    virtual ~UObjRefToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UNameIndexToken : public UScriptToken
+{
+public:
+    UNameIndexToken() {}
+    virtual ~UNameIndexToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class ULocalVariableToken : public UObjRefToken
+{
+public:
+    ULocalVariableToken() { Type = UToken::LocalVariable; }
+    ~ULocalVariableToken() {}
+};
+
+class UInstanceVariableToken : public UObjRefToken
+{
+public:
+    UInstanceVariableToken() { Type = UToken::InstanceVariable; }
+    ~UInstanceVariableToken() {}
+};
+
+class UDefaultVariableToken : public UObjRefToken
+{
+public:
+    UDefaultVariableToken() { Type = UToken::DefaultVariable; }
+    ~UDefaultVariableToken() {}
+};
+
+class UStateVariableToken : public UObjRefToken
+{
+public:
+    UStateVariableToken() { Type = UToken::StateVariable; }
+    ~UStateVariableToken() {}
+};
+
+class UReturnToken : public UExpressionToken
+{
+public:
+    UReturnToken() { Type = UToken::Return; }
+    ~UReturnToken() {}
+};
+
+class USwitchToken : public UObjRefToken
+{
+public:
+    USwitchToken() { Type = UToken::Switch; }
+    ~USwitchToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UJumpToken : public UScriptToken
+{
+public:
+    UJumpToken() { Type = UToken::Jump; }
+    ~UJumpToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UJumpIfNotToken : public UJumpToken
+{
+public:
+    UJumpIfNotToken() { Type = UToken::JumpIfNot; }
+    ~UJumpIfNotToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UStopToken : public UScriptToken
+{
+public:
+    UStopToken() { Type = UToken::Stop; }
+    ~UStopToken() {}
+};
+
+class UAssertToken : public UScriptToken
+{
+public:
+    UAssertToken() { Type = UToken::Assert; }
+    ~UAssertToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UCaseToken : public UJumpToken
+{
+public:
+    UCaseToken() { Type = UToken::Case; }
+    ~UCaseToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UNothingToken : public UScriptToken
+{
+public:
+    UNothingToken() { Type = UToken::Nothing; }
+    ~UNothingToken() {}
+};
+
+class ULabelTableToken : public UScriptToken
+{
+public:
+    ULabelTableToken() { Type = UToken::LabelTable; }
+    ~ULabelTableToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UGotoLabelToken : public UExpressionToken
+{
+public:
+    UGotoLabelToken() { Type = UToken::GotoLabel; }
+    ~UGotoLabelToken() {}
+};
+
+class UEatStringToken : public UObjRefToken
+{
+public:
+    UEatStringToken() { Type = UToken::EatString; }
+    ~UEatStringToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class ULetToken : public UExpressionToken
+{
+public:
+    ULetToken() { Type = UToken::Let; Count = 2; }
+    ~ULetToken() {}
+};
+
+class UDynArrayElementToken : public UExpressionToken
+{
+public:
+    UDynArrayElementToken() { Type = UToken::DynArrayElement; Count = 2; }
+    ~UDynArrayElementToken() {}
+};
+
+class UNewToken : public UExpressionToken
+{
+public:
+    UNewToken() { Type = UToken::New; Count = 5; }
+    ~UNewToken() {}
+};
+
+class UClassContextToken : public UScriptToken
+{
+public:
+    UClassContextToken() { Type = UToken::ClassContext; }
+    ~UClassContextToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UMetaCastToken : public UEatStringToken
+{
+public:
+    UMetaCastToken() { Type = UToken::MetaCast; }
+    ~UMetaCastToken() {}
+};
+
+class ULetBoolToken : public ULetToken
+{
+public:
+    ULetBoolToken() { Type = UToken::LetBool; }
+    ~ULetBoolToken() {}
+};
+
+class UEndParmValueToken : public UScriptToken
+{
+public:
+    UEndParmValueToken() { Type = UToken::EndParmValue; }
+    ~UEndParmValueToken() {}
+};
+
+class UEndFunctionParmsToken : public UScriptToken
+{
+public:
+    UEndFunctionParmsToken() { Type = UToken::EndFunctionParms; }
+    ~UEndFunctionParmsToken() {}
+};
+
+class USelfToken : public UScriptToken
+{
+public:
+    USelfToken() { Type = UToken::Self; }
+    ~USelfToken() {}
+};
+
+class USkipToken : public UScriptToken
+{
+public:
+    USkipToken() { Type = UToken::Skip; }
+    ~USkipToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UContextToken : public UClassContextToken
+{
+public:
+    UContextToken() { Type = UToken::Context; }
+    ~UContextToken() {}
+};
+
+class UArrayElementToken : public UDynArrayElementToken
+{
+public:
+    UArrayElementToken() { Type = UToken::ArrayElement; }
+    ~UArrayElementToken() {}
+};
+
+class UVirtualFunctionToken : public UScriptToken
+{
+public:
+    UVirtualFunctionToken() { Type = UToken::VirtualFunction; }
+    ~UVirtualFunctionToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UFinalFunctionToken : public UScriptToken
+{
+public:
+    UFinalFunctionToken() { Type = UToken::FinalFunction; }
+    ~UFinalFunctionToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UIntConstToken : public UScriptToken
+{
+public:
+    UIntConstToken() { Type = UToken::IntConst; }
+    ~UIntConstToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UFloatConstToken : public UScriptToken
+{
+public:
+    UFloatConstToken() { Type = UToken::FloatConst; }
+    ~UFloatConstToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UStringConstToken : public UScriptToken
+{
+public:
+    UStringConstToken() { Type = UToken::StringConst; }
+    ~UStringConstToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UObjectConstToken : public UObjRefToken
+{
+public:
+    UObjectConstToken() { Type = UToken::ObjectConst; }
+    ~UObjectConstToken() {}
+};
+
+class UNameConstToken : public UNameIndexToken
+{
+public:
+    UNameConstToken() { Type = UToken::NameConst; }
+    ~UNameConstToken() {}
+};
+
+class URotatorConstToken : public UScriptToken
+{
+public:
+    URotatorConstToken() { Type = UToken::RotatorConst; }
+    ~URotatorConstToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UVectorConstToken : public UScriptToken
+{
+public:
+    UVectorConstToken() { Type = UToken::VectorConst; }
+    ~UVectorConstToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UByteConstToken : public UScriptToken
+{
+public:
+    UByteConstToken() { Type = UToken::ByteConst; }
+    ~UByteConstToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UIntZeroToken : public UScriptToken
+{
+public:
+    UIntZeroToken() { Type = UToken::IntZero; }
+    ~UIntZeroToken() {}
+};
+
+class UIntOneToken : public UScriptToken
+{
+public:
+    UIntOneToken() { Type = UToken::IntOne; }
+    ~UIntOneToken() {}
+};
+
+class UTrueToken : public UScriptToken
+{
+public:
+    UTrueToken() { Type = UToken::True; }
+    ~UTrueToken() {}
+};
+
+class UFalseToken : public UScriptToken
+{
+public:
+    UFalseToken() { Type = UToken::False; }
+    ~UFalseToken() {}
+};
+
+class UNativeParmToken : public UScriptToken
+{
+public:
+    UNativeParmToken() { Type = UToken::NativeParm; }
+    ~UNativeParmToken() {}
+};
+
+class UNoObjectToken : public UScriptToken
+{
+public:
+    UNoObjectToken() { Type = UToken::NoObject; }
+    ~UNoObjectToken() {}
+};
+
+class UIntConstByteToken : public UByteConstToken
+{
+public:
+    UIntConstByteToken() { Type = UToken::IntConstByte; }
+    ~UIntConstByteToken() {}
+};
+
+class UBoolVariableToken : public UExpressionToken
+{
+public:
+    UBoolVariableToken() { Type = UToken::BoolVariable; }
+    ~UBoolVariableToken() {}
+};
+
+class UDynamicCastToken : public UMetaCastToken
+{
+public:
+    UDynamicCastToken() { Type = UToken::DynamicCast; }
+    ~UDynamicCastToken() {}
+};
+
+class UIteratorToken : public UScriptToken
+{
+public:
+    UIteratorToken() { Type = UToken::Iterator; }
+    ~UIteratorToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UIteratorPopToken : public UScriptToken
+{
+public:
+    UIteratorPopToken() { Type = UToken::IteratorPop; }
+    ~UIteratorPopToken() {}
+};
+
+class UIteratorNextToken : public UScriptToken
+{
+public:
+    UIteratorNextToken() { Type = UToken::IteratorNext; }
+    ~UIteratorNextToken() {}
+};
+
+class UStructCmpEqToken : public UExpressionToken
+{
+public:
+    UStructCmpEqToken() { Type = UToken::StructCmpEq; Count = 2; }
+    ~UStructCmpEqToken() {}
+};
+
+class UStructCmpNeToken : public UExpressionToken
+{
+public:
+    UStructCmpNeToken() { Type = UToken::StructCmpNe; Count = 2; }
+    ~UStructCmpNeToken() {}
+};
+
+class UUniStringConstToken : public UStringConstToken /// stub!
+{
+public:
+    UUniStringConstToken() { Type = UToken::UniStringConst; }
+    ~UUniStringConstToken() {}
+};
+
+class UStructMemberToken : public UScriptToken
+{
+public:
+    UStructMemberToken() { Type = UToken::StructMember; }
+    ~UStructMemberToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UDynArrayLenToken : public UExpressionToken
+{
+public:
+    UDynArrayLenToken() { Type = UToken::DynArrayLen; }
+    ~UDynArrayLenToken() {}
+};
+
+class UGlobalFunctionToken : public UExpressionToken
+{
+public:
+    UGlobalFunctionToken() { Type = UToken::GlobalFunction; }
+    ~UGlobalFunctionToken() {}
+};
+
+class UPrimitiveCastToken : public UScriptToken
+{
+public:
+    UPrimitiveCastToken() { Type = UToken::PrimitiveCast; }
+    ~UPrimitiveCastToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UDynArrayInsertToken : public UExpressionToken
+{
+public:
+    UDynArrayInsertToken() { Type = UToken::DynArrayInsert; Count = 4; }
+    ~UDynArrayInsertToken() {}
+};
+
+class UReturnNothingToken : public UObjRefToken
+{
+public:
+    UReturnNothingToken() { Type = UToken::ReturnNothing; }
+    ~UReturnNothingToken() {}
+};
+
+class UDelegateCmpEqToken : public UExpressionToken
+{
+public:
+    UDelegateCmpEqToken() { Type = UToken::DelegateCmpEq; Count = 3; }
+    ~UDelegateCmpEqToken() {}
+};
+
+class UDelegateCmpNeToken : public UExpressionToken
+{
+public:
+    UDelegateCmpNeToken() { Type = UToken::DelegateCmpNe; Count = 3; }
+    ~UDelegateCmpNeToken() {}
+};
+
+class UDelegateFunctionCmpEqToken : public UExpressionToken
+{
+public:
+    UDelegateFunctionCmpEqToken() { Type = UToken::DelegateFunctionCmpEq; Count = 3; }
+    ~UDelegateFunctionCmpEqToken() {}
+};
+
+class UDelegateFunctionCmpNeToken : public UExpressionToken
+{
+public:
+    UDelegateFunctionCmpNeToken() { Type = UToken::DelegateFunctionCmpNE; Count = 3; }
+    ~UDelegateFunctionCmpNeToken() {}
+};
+
+class UNoDelegateToken : public UScriptToken
+{
+public:
+    UNoDelegateToken() { Type = UToken::NoDelegate; }
+    ~UNoDelegateToken() {}
+};
+
+class UDynArrayRemoveToken : public UExpressionToken
+{
+public:
+    UDynArrayRemoveToken() { Type = UToken::DynArrayRemove; Count = 4; }
+    ~UDynArrayRemoveToken() {}
+};
+
+class UDebugInfoToken : public UScriptToken
+{
+public:
+    UDebugInfoToken() { Type = UToken::DebugInfo; }
+    ~UDebugInfoToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UDelegateFunctionToken : public UScriptToken
+{
+public:
+    UDelegateFunctionToken() { Type = UToken::DelegateFunction; }
+    ~UDelegateFunctionToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UDelegatePropertyToken : public UScriptToken
+{
+public:
+    UDelegatePropertyToken() { Type = UToken::DelegateProperty; }
+    ~UDelegatePropertyToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class ULetDelegateToken : public ULetToken
+{
+public:
+    ULetDelegateToken() { Type = UToken::LetDelegate; }
+    ~ULetDelegateToken() {}
+};
+
+class UTernaryConditionToken : public UScriptToken
+{
+public:
+    UTernaryConditionToken() { Type = UToken::TernaryCondition; }
+    ~UTernaryConditionToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UDynArrFindToken : public UScriptToken
+{
+public:
+    UDynArrFindToken() { Type = UToken::DynArrFind; }
+    ~UDynArrFindToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UDynArrayFindStructToken : public UScriptToken
+{
+public:
+    UDynArrayFindStructToken() { Type = UToken::DynArrayFindStruct; }
+    ~UDynArrayFindStructToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UOutVariableToken : public UObjRefToken
+{
+public:
+    UOutVariableToken() { Type = UToken::OutVariable; }
+    ~UOutVariableToken() {}
+};
+
+class UDefaultParmValueToken : public UScriptToken
+{
+public:
+    UDefaultParmValueToken() { Type = UToken::DefaultParmValue; }
+    ~UDefaultParmValueToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UNoParmToken : public UScriptToken
+{
+public:
+    UNoParmToken() { Type = UToken::NoParm; }
+    ~UNoParmToken() {}
+};
+
+class UInstanceDelegateToken : public UNameIndexToken
+{
+public:
+    UInstanceDelegateToken() { Type = UToken::InstanceDelegate; }
+    ~UInstanceDelegateToken() {}
+};
+
+class UInterfaceContextToken : public UExpressionToken
+{
+public:
+    UInterfaceContextToken() { Type = UToken::InterfaceContext; }
+    ~UInterfaceContextToken() {}
+};
+
+class UInterfaceCastToken : public UMetaCastToken
+{
+public:
+    UInterfaceCastToken() { Type = UToken::InterfaceCast; }
+    ~UInterfaceCastToken() {}
+};
+
+class UEndOfScriptToken : public UScriptToken
+{
+public:
+    UEndOfScriptToken() { Type = UToken::EndOfScript; }
+    ~UEndOfScriptToken() {}
+};
+
+class UDynArrAddToken : public UExpressionToken
+{
+public:
+    UDynArrAddToken() { Type = UToken::DynArrAdd; Count = 2; }
+    ~UDynArrAddToken() {}
+};
+
+class UDynArrAddItemToken : public UDynArrFindToken
+{
+public:
+    UDynArrAddItemToken() { Type = UToken::DynArrAddItem; }
+    ~UDynArrAddItemToken() {}
+};
+
+class UDynArrRemoveItemToken : public UDynArrAddItemToken
+{
+public:
+    UDynArrRemoveItemToken() { Type = UToken::DynArrRemoveItem; }
+    ~UDynArrRemoveItemToken() {}
+};
+
+class UDynArrInsertItemToken : public UDynArrayFindStructToken
+{
+public:
+    UDynArrInsertItemToken() { Type = UToken::DynArrInsertItem; }
+    ~UDynArrInsertItemToken() {}
+};
+
+class UDynArrIteratorToken : public UScriptToken
+{
+public:
+    UDynArrIteratorToken() { Type = UToken::DynArrIterator; }
+    ~UDynArrIteratorToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+class UDynArrSortToken : public UDynArrFindToken
+{
+public:
+    UDynArrSortToken() { Type = UToken::DynArrSort; }
+    ~UDynArrSortToken() {}
+};
+
+class UUnknownDeprecatedToken : public UScriptToken
+{
+public:
+    UUnknownDeprecatedToken(UToken T) { Type = T; }
+    UUnknownDeprecatedToken() { Type = UToken::UnknownDeprecated; }
+    ~UUnknownDeprecatedToken() {}
+};
+
+class UUnknownDynamicVariableToken : public UScriptToken
+{
+public:
+    UUnknownDynamicVariableToken(UToken T) { Type = T; }
+    UUnknownDynamicVariableToken() { Type = UToken::UnknownDynamicVariable1; }
+    ~UUnknownDynamicVariableToken() {}
+};
+
+class UUnknownFilterEditorOnlyToken : public UScriptToken
+{
+public:
+    UUnknownFilterEditorOnlyToken(UToken T) { Type = T; }
+    UUnknownFilterEditorOnlyToken() { Type = UToken::UnknownFilterEditorOnly1; }
+    ~UUnknownFilterEditorOnlyToken() {}
+};
+
+class UNativeFunctionToken : public UScriptToken
+{
+public:
+    UNativeFunctionToken(UToken T) { Type = T; }
+    UNativeFunctionToken() { Type = UToken::ExtendedNative; }
+    ~UNativeFunctionToken() {}
+    std::string Deserialize(std::istream& stream, UPKInfo& info);
+};
+
+#endif // UTOKEN_H
diff --git a/UTokenFactory.cpp b/UTokenFactory.cpp
new file mode 100644
index 0000000..bfb5804
--- /dev/null
+++ b/UTokenFactory.cpp
@@ -0,0 +1,361 @@
+#include "UTokenFactory.h"
+
+UScriptToken* UTokenFactory::Create(UToken Type)
+{
+	if (Type == UToken::LocalVariable)
+	{
+		return new ULocalVariableToken;
+	}
+	else if (Type == UToken::InstanceVariable)
+	{
+		return new UInstanceVariableToken;
+	}
+	else if (Type == UToken::DefaultVariable)
+	{
+		return new UDefaultVariableToken;
+	}
+	else if (Type == UToken::StateVariable)
+	{
+		return new UStateVariableToken;
+	}
+	else if (Type == UToken::Return)
+	{
+		return new UReturnToken;
+	}
+	else if (Type == UToken::Switch)
+	{
+		return new USwitchToken;
+	}
+	else if (Type == UToken::Jump)
+	{
+		return new UJumpToken;
+	}
+	else if (Type == UToken::JumpIfNot)
+	{
+		return new UJumpIfNotToken;
+	}
+	else if (Type == UToken::Stop)
+	{
+		return new UStopToken;
+	}
+	else if (Type == UToken::Assert)
+	{
+		return new UAssertToken;
+	}
+	else if (Type == UToken::Case)
+	{
+		return new UCaseToken;
+	}
+	else if (Type == UToken::Nothing)
+	{
+		return new UNothingToken;
+	}
+	else if (Type == UToken::LabelTable)
+	{
+		return new ULabelTableToken;
+	}
+	else if (Type == UToken::GotoLabel)
+	{
+		return new UGotoLabelToken;
+	}
+	else if (Type == UToken::EatString)
+	{
+		return new UEatStringToken;
+	}
+	else if (Type == UToken::Let)
+	{
+		return new ULetToken;
+	}
+	else if (Type == UToken::DynArrayElement)
+	{
+		return new UDynArrayElementToken;
+	}
+	else if (Type == UToken::New)
+	{
+		return new UNewToken;
+	}
+	else if (Type == UToken::ClassContext)
+	{
+		return new UClassContextToken;
+	}
+	else if (Type == UToken::MetaCast)
+	{
+		return new UMetaCastToken;
+	}
+	else if (Type == UToken::LetBool)
+	{
+		return new ULetBoolToken;
+	}
+	else if (Type == UToken::EndParmValue)
+	{
+		return new UEndParmValueToken;
+	}
+	else if (Type == UToken::EndFunctionParms)
+	{
+		return new UEndFunctionParmsToken;
+	}
+	else if (Type == UToken::Self)
+	{
+		return new USelfToken;
+	}
+	else if (Type == UToken::Skip)
+	{
+		return new USkipToken;
+	}
+	else if (Type == UToken::Context)
+	{
+		return new UContextToken;
+	}
+	else if (Type == UToken::ArrayElement)
+	{
+		return new UArrayElementToken;
+	}
+	else if (Type == UToken::VirtualFunction)
+	{
+		return new UVirtualFunctionToken;
+	}
+	else if (Type == UToken::FinalFunction)
+	{
+		return new UFinalFunctionToken;
+	}
+	else if (Type == UToken::IntConst)
+	{
+		return new UIntConstToken;
+	}
+	else if (Type == UToken::FloatConst)
+	{
+		return new UFloatConstToken;
+	}
+	else if (Type == UToken::StringConst)
+	{
+		return new UStringConstToken;
+	}
+	else if (Type == UToken::ObjectConst)
+	{
+		return new UObjectConstToken;
+	}
+	else if (Type == UToken::NameConst)
+	{
+		return new UNameConstToken;
+	}
+	else if (Type == UToken::RotatorConst)
+	{
+		return new URotatorConstToken;
+	}
+	else if (Type == UToken::VectorConst)
+	{
+		return new UVectorConstToken;
+	}
+	else if (Type == UToken::ByteConst)
+	{
+		return new UByteConstToken;
+	}
+	else if (Type == UToken::IntZero)
+	{
+		return new UIntZeroToken;
+	}
+	else if (Type == UToken::IntOne)
+	{
+		return new UIntOneToken;
+	}
+	else if (Type == UToken::True)
+	{
+		return new UTrueToken;
+	}
+	else if (Type == UToken::False)
+	{
+		return new UFalseToken;
+	}
+	else if (Type == UToken::NativeParm)
+	{
+		return new UNativeParmToken;
+	}
+	else if (Type == UToken::NoObject)
+	{
+		return new UNoObjectToken;
+	}
+	else if (Type == UToken::UnknownDeprecated)
+	{
+		return new UUnknownDeprecatedToken(Type);
+	}
+	else if (Type == UToken::IntConstByte)
+	{
+		return new UIntConstByteToken;
+	}
+	else if (Type == UToken::BoolVariable)
+	{
+		return new UBoolVariableToken;
+	}
+	else if (Type == UToken::DynamicCast)
+	{
+		return new UDynamicCastToken;
+	}
+	else if (Type == UToken::Iterator)
+	{
+		return new UIteratorToken;
+	}
+	else if (Type == UToken::IteratorPop)
+	{
+		return new UIteratorPopToken;
+	}
+	else if (Type == UToken::IteratorNext)
+	{
+		return new UIteratorNextToken;
+	}
+	else if (Type == UToken::StructCmpEq)
+	{
+		return new UStructCmpEqToken;
+	}
+	else if (Type == UToken::StructCmpNe)
+	{
+		return new UStructCmpNeToken;
+	}
+	else if (Type == UToken::UniStringConst)
+	{
+		return new UUniStringConstToken;
+	}
+	else if (Type == UToken::StructMember)
+	{
+		return new UStructMemberToken;
+	}
+	else if (Type == UToken::DynArrayLen)
+	{
+		return new UDynArrayLenToken;
+	}
+	else if (Type == UToken::GlobalFunction)
+	{
+		return new UGlobalFunctionToken;
+	}
+	else if (Type == UToken::PrimitiveCast)
+	{
+		return new UPrimitiveCastToken;
+	}
+	else if (Type == UToken::DynArrayInsert)
+	{
+		return new UDynArrayInsertToken;
+	}
+	else if (Type == UToken::ReturnNothing)
+	{
+		return new UReturnNothingToken;
+	}
+	else if (Type == UToken::DelegateCmpEq)
+	{
+		return new UDelegateCmpEqToken;
+	}
+	else if (Type == UToken::DelegateCmpNe)
+	{
+		return new UDelegateCmpNeToken;
+	}
+	else if (Type == UToken::DelegateFunctionCmpEq)
+	{
+		return new UDelegateFunctionCmpEqToken;
+	}
+	else if (Type == UToken::DelegateFunctionCmpNE)
+	{
+		return new UDelegateFunctionCmpNeToken;
+	}
+	else if (Type == UToken::NoDelegate)
+	{
+		return new UNoDelegateToken;
+	}
+	else if (Type == UToken::DynArrayRemove)
+	{
+		return new UDynArrayRemoveToken;
+	}
+	else if (Type == UToken::DebugInfo)
+	{
+		return new UDebugInfoToken;
+	}
+	else if (Type == UToken::DelegateFunction)
+	{
+		return new UDelegateFunctionToken;
+	}
+	else if (Type == UToken::DelegateProperty)
+	{
+		return new UDelegatePropertyToken;
+	}
+	else if (Type == UToken::LetDelegate)
+	{
+		return new ULetDelegateToken;
+	}
+	else if (Type == UToken::TernaryCondition)
+	{
+		return new UTernaryConditionToken;
+	}
+	else if (Type == UToken::DynArrFind)
+	{
+		return new UDynArrFindToken;
+	}
+	else if (Type == UToken::DynArrayFindStruct)
+	{
+		return new UDynArrayFindStructToken;
+	}
+	else if (Type == UToken::OutVariable)
+	{
+		return new UOutVariableToken;
+	}
+	else if (Type == UToken::DefaultParmValue)
+	{
+		return new UDefaultParmValueToken;
+	}
+	else if (Type == UToken::NoParm)
+	{
+		return new UNoParmToken;
+	}
+	else if (Type == UToken::InstanceDelegate)
+	{
+		return new UInstanceDelegateToken;
+	}
+	else if (Type >= UToken::UnknownDynamicVariable1 && Type <= UToken::UnknownDynamicVariable5)
+	{
+		return new UUnknownDynamicVariableToken(Type);
+	}
+	else if (Type == UToken::InterfaceContext)
+	{
+		return new UInterfaceContextToken;
+	}
+	else if (Type == UToken::InterfaceCast)
+	{
+		return new UInterfaceCastToken;
+	}
+	else if (Type == UToken::EndOfScript)
+	{
+		return new UEndOfScriptToken;
+	}
+	else if (Type == UToken::DynArrAdd)
+	{
+		return new UDynArrAddToken;
+	}
+	else if (Type == UToken::DynArrAddItem)
+	{
+		return new UDynArrAddItemToken;
+	}
+	else if (Type == UToken::DynArrRemoveItem)
+	{
+		return new UDynArrRemoveItemToken;
+	}
+	else if (Type == UToken::DynArrInsertItem)
+	{
+		return new UDynArrInsertItemToken;
+	}
+	else if (Type == UToken::DynArrIterator)
+	{
+		return new UDynArrIteratorToken;
+	}
+	else if (Type == UToken::DynArrSort)
+	{
+		return new UDynArrSortToken;
+	}
+	else if (Type >= UToken::UnknownFilterEditorOnly1 && Type <= UToken::UnknownFilterEditorOnly6)
+	{
+		return new UUnknownFilterEditorOnlyToken(Type);
+	}
+	else if (Type >= UToken::ExtendedNative && Type <= UToken::NativeFunctionF)
+	{
+		return new UNativeFunctionToken(Type);
+	}
+    else
+    {
+        return nullptr;
+    }
+}
diff --git a/UTokenFactory.h b/UTokenFactory.h
new file mode 100644
index 0000000..3859225
--- /dev/null
+++ b/UTokenFactory.h
@@ -0,0 +1,14 @@
+#ifndef UTOKENFACTORY_H
+#define UTOKENFACTORY_H
+
+#include "UToken.h"
+
+class UTokenFactory
+{
+    public:
+        UTokenFactory() {};
+        ~UTokenFactory() {};
+        static UScriptToken* Create(UToken Type);
+};
+
+#endif // UTOKENFACTORY_H
diff --git a/build/CMakeLists.txt b/build/CMakeLists.txt
index 9908ab9..3527289 100644
--- a/build/CMakeLists.txt
+++ b/build/CMakeLists.txt
@@ -14,6 +14,8 @@ ADD_LIBRARY(UObjectFactory ../UObjectFactory.cpp ../UObjectFactory.h)
 ADD_LIBRARY(UPKInfo ../UPKInfo.cpp ../UPKInfo.h)
 ADD_LIBRARY(UPKUtils ../UPKUtils.cpp ../UPKUtils.h)
 ADD_LIBRARY(minilzo ../minilzo.c ../minilzo.h ../lzodefs.h ../lzoconf.h)
+ADD_LIBRARY(UToken ../UToken.cpp ../UToken.h)
+ADD_LIBRARY(UTokenFactory ../UTokenFactory.cpp ../UTokenFactory.h)
 
 ADD_EXECUTABLE(CompareUPK ../CompareUPK.cpp)
 ADD_EXECUTABLE(ExtractNameLists ../ExtractNameLists.cpp)
@@ -22,6 +24,7 @@ ADD_EXECUTABLE(FindObjectEntry ../FindObjectEntry.cpp)
 ADD_EXECUTABLE(MoveExpandFunction ../MoveExpandFunction.cpp)
 ADD_EXECUTABLE(PatchUPK ../PatchUPK.cpp)
 ADD_EXECUTABLE(DecompressLZO ../DecompressLZO.cpp)
+ADD_EXECUTABLE(HexToPseudoCode ../HexToPseudoCode.cpp)
 
 TARGET_LINK_LIBRARIES(CompareUPK UPKInfo)
 TARGET_LINK_LIBRARIES(ExtractNameLists UPKInfo)
@@ -30,6 +33,7 @@ TARGET_LINK_LIBRARIES(FindObjectEntry UPKInfo UPKUtils UObject UObjectFactory)
 TARGET_LINK_LIBRARIES(MoveExpandFunction UPKInfo UPKUtils UObject UObjectFactory)
 TARGET_LINK_LIBRARIES(PatchUPK ModScript ModParser UPKInfo UPKUtils UObject UObjectFactory)
 TARGET_LINK_LIBRARIES(DecompressLZO minilzo UPKInfo)
+TARGET_LINK_LIBRARIES(HexToPseudoCode UPKInfo UPKUtils UObject UObjectFactory UToken UTokenFactory)
 
 IF(wxWidgets_USE_MONOLITHIC)
 SET(wxWidgets_USE_LIBS mono)
diff --git a/doc/PatchUPK_Mod_Example.txt b/doc/PatchUPK_Mod_Example.txt
index acd5f9f..05209c8 100644
--- a/doc/PatchUPK_Mod_Example.txt
+++ b/doc/PatchUPK_Mod_Example.txt
@@ -14,12 +14,12 @@ Compatible with XCOM Enemy Unknown / Enemy Within version:
  - versions list
 
 
-// Next line is here to generate error and prevent accidental installation of the sample.
+// Next line was placed here to generate error and prevent accidental installation of the sample.
 UPK_FILE=FileDoesNotExist.upk
  
 { Curly brackets are used for comments.
-  Comments may be multi-line.
-  Try not to forget close brackets opened. }
+  Comments can be multi-line.
+  Do not forget to close opened brackets. }
   
 { Do not use curly brackets inside comments!!! }
 
@@ -32,27 +32,27 @@ UPK_FILE=FileDoesNotExist.upk
 /* Open XComStrategyGame.upk
    Do not add path to upk file if you're using it with PatcherGUI!
    You need to open upk file only once to apply multiple changes,
-   but you still may use ToolBoks style and set upk file name for every single change:
-   file will not be reopened. */
+   but you still can use ToolBoks style and specify upk file name for every single change:
+   the file will not be reopened. */
 UPK_FILE=XComStrategyGame.upk
 
-// ToolBoks-style patching, using absolute offsets and binary replacement data
+// ToolBoks-style patching: absolute offsets followed by binary replacement data
 
-/* Offsets can be dec or hex values. Hex values must begin with 0x
-   Offset key sets patching scope to entire UPK. You can change anything, except
+/* Offsets can be dec or hex values. Hex values should begin with 0x
+   Offset key sets patching scope to entire UPK file. You can change anything, except
    first 8 bytes: package signature and version.  */
 OFFSET=0x1234ABC
 [MODDED_HEX]
-// You may use comments here...
+// You can use comments here...
 00 01 0A 0B FF  /* ... and here... */ 00 AA /* ... and here... */
 01 23
 45
 
 // Using external binary files
 
-/* If you're using PatcherGUI, path to binary file must be either absolute or relative to mod file
-   (Your_mod_file_name.txt) location.
-   File name must match Full.Object.Name.ext pattern. Allowed extensions are:
+/* If you're using PatcherGUI, path to binary file should be either absolute
+   or relative to mod file (Your_mod_file_name.txt) location.
+   File name should match Full.Object.Name.ext pattern. Allowed extensions are:
    .NameEntry for NameTable entry
    .ImportEntry for ImportTable entry
    .ExportEntry for ExportTable entry */
@@ -60,35 +60,39 @@ MODDED_FILE=Path-to-file/Full.Object.Name.ext
 
 // User-friendly way to set values
 
-// You may use BYTE key to set single byte value. Byte values are unsigned!
+// You can use BYTE key to set single byte value. Byte values are unsigned!
 BYTE=0x0A { hex }
 BYTE=10   { or dec }
 
-// You may use FLOAT key to set 4-byte floating point value
+// You can use FLOAT key to set 4-byte floating point value.
 FLOAT=123.4
 
-/* You may use INTEGER key to set 4-byte integer value.
+/* You can use INTEGER key to set 4-byte integer value.
   WARNING! No hex values are allowed! For hex representation use UNSIGNED key! */
 INTEGER=15
 
-// You may use UNSIGNED key to set 4-byte unsigned integer value.
+// You can use UNSIGNED key to set 4-byte unsigned integer value.
 UNSIGNED=0xA { hex }
 UNSIGNED=10  { or dec }
 
 // Object-oriented patching
 
-// You may use full object name as it is shown in UE Explorer to calculate its offset automatically
+// You can use full object name (as it is shown in UE Explorer) to find it inside UPK file
 OBJECT=XGBattleDesc.InitAlienLoadoutInfos
 OBJECT=XGStrategyAI.GetAltWeapon:AUTO
+OBJECT=XGStrategyAI.GetAltWeapon:INPL
 OBJECT=XGStrategyAI.GetAltWeapon:MOVE
 OBJECT=XGStrategyAI.GetAltWeapon:KEEP
-/* Empty specifier is equal to KEEP. KEEP is the safest behaviour: all changes applied to current scope only and
-   if data chunk length exceeds current scope, program will generate an error.
-   MOVE forces the object move before applying any changes.
+/* Empty specifier is equal to KEEP. KEEP is the safest behaviour: all changes are applied
+   to current scope only and if data chunk length exceeds current scope, program will
+   output an error.
+   MOVE forces moving object's data to the end of UPK file before applying any changes.
    AUTO allows program to auto-move/resize object when needed.
-   Note that specifiers themselves do not make any changes: they work when you start to write actual data. */
+   INPL works similar to AUTO, but performs object resize in place without moving.
+   Note that specifiers themselves do not make any changes: they work when you start to
+   write actual data. */
 
-/* You may use relative offsets to patch data inside specified object.
+/* You can use relative offsets to patch data inside specified object.
    If current scope is set to package, relative offset will be added to global offset. */
 REL_OFFSET=0x28
 
@@ -97,13 +101,13 @@ REL_OFFSET=0x28
 // Rename GetAltWeapon to #GetPodProgs
 RENAME=GetAltWeapon:#GetPodProgs
 
-/* You may expand function by specifying its new ObjectSize
+/* You can expand function by specifying its new ObjectSize
    (not file size from script header, but full data chunk length!)
    If new size is equal to old size, function will not be expanded.
    EXPAND_FUNCTION sets current offset value to new data offset,
    so you don't need to specify offset after using it. */
 EXPAND_FUNCTION=XGStrategyAI.GetAltWeapon:300
-// You may undo function expand.
+// You can undo function expand.
 EXPAND_UNDO=XGStrategyAI.GetAltWeapon
 
 // Before-after style patching
@@ -118,7 +122,7 @@ BB AC 22 13
 
 // Using pseudo-code
 
-// You may use pseudo-code instead of hex references. For more info see PatchUPK_Readme.txt.
+// You can use pseudo-code instead of hex references. For more info see PatchUPK_Readme.txt.
 OBJECT=XGStrategyAI.GetNumOutsiders
 [REPLACEMENT_CODE]
 // if(Game().GetDifficulty() >= 2)
diff --git a/doc/PatchUPK_Readme.txt b/doc/PatchUPK_Readme.txt
index 61e6318..f7bf3c2 100644
--- a/doc/PatchUPK_Readme.txt
+++ b/doc/PatchUPK_Readme.txt
@@ -1,29 +1,27 @@
 -----------------------------------------------------------------------------------------------------------------
-    UPK Utils: PatchUPK documentation file
+    PatchUPK documentation file
 -----------------------------------------------------------------------------------------------------------------
 
-PatchUPK is a Windows console utility to patch XCOM packages (upk files). Packages must be decompressed first
-(using DecompressLZO or Gildor's decompress.exe for Windows).
+PatchUPK is a console application for patching XCOM packages (upk files). Packages must be decompressed first
+(using DecompressLZO or Gildor's decompress.exe).
 
 PatchUPK operates on special script files and applies subsequent changes to packages.
 
-Version 6.1, 10/03/2014
-
-Wasteland Ghost aka wghost81 (wghost81@gmail.com).
-
 -----------------------------------------------------------------------------------------------------------------
     Script commands basics
 -----------------------------------------------------------------------------------------------------------------
 
-There are two types of commands: keys and sections. Keys are followed by '=' sign to separate them from values
-and sections are enclosed into brackets '[' and ']'.
+There are two types of commands: keys and sections. Keys are followed by '=' character to separate them from
+values and sections are enclosed into brackets '[' and ']'.
+
+Keys can have additional specifiers separated by ':' character.
 
 -----------------------------------------------------------------------------------------------------------------
     Comments
 -----------------------------------------------------------------------------------------------------------------
 
-PatchUPK supports two types of comments: curly brackets comments (enclosed in  '{' and '}') and C-style comments.
-You may use comments anywhere in the mod file. Examples:
+PatchUPK supports two types of comments: curly brackets (text enclosed in '{' and '}') and C-style comments.
+You can use comments anywhere inside a file. Examples:
 /* Multi-line
    comment */
 // Line comment
@@ -41,188 +39,183 @@ of the file to select what parts of your mod can be uninstalled safely and what
 
 UPDATE_REL key allows to switch relative offset auto-update on and off. Default behavior is off. UPDATE_REL=TRUE
 forces Patcher to update relative offset after each write operation. UPDATE_REL=FALSE tells Patcher to keep
-relative offset intact.
+relative offset unchanged.
 
 -----------------------------------------------------------------------------------------------------------------
     Optional keys
 -----------------------------------------------------------------------------------------------------------------
 
-MOD_NAME, AUTHOR and DESCRIPTION keys are used to provide author and mod information and may be used as mod's
+MOD_NAME, AUTHOR and DESCRIPTION keys are used to provide author and mod information and can be used as mod's
 readme.
 
 -----------------------------------------------------------------------------------------------------------------
     Loading a package
 -----------------------------------------------------------------------------------------------------------------
 
-GUID key adds specified GUID to allowed GUIDs list. Example:
+GUID key adds the GUID to list of allowed GUIDs. Example:
 GUID=3F3B9C3140E45D9C8E92AFABF2746525:XComStrategyGame.upk
-GUID value must correspond with the output of ExtractNameLists program! You may add multiple GUIDs for the same
-package and multiple GUIDs for multiple packages. Use GUID key before you load a package with UPK_FILE key!
+GUID value should correspond with the output of ExtractNameLists program! You can add multiple GUIDs for the same
+package and multiple GUIDs for multiple packages. Declare allowed GUIDs before you start loading a package!
 
 UPK_FILE key loads a package. Example:
 UPK_FILE=XComGame.upk
-Patcher opens the specified package, reads its header info, reconstructs full object names and additional info
-for "smart" patching operations, so this command may take a while to complete.
-If specified package is already opened, patcher will not try to re-open it.
+Patcher opens the package, reads its header info, reconstructs full object names and additional info for "smart"
+patching operations, so this command may take a while to complete. If the package is already opened, patcher
+will not try to re-open it.
     
 -----------------------------------------------------------------------------------------------------------------
     Setting a scope
 -----------------------------------------------------------------------------------------------------------------
 
-There currently are four different scopes:
+There currently are five different scopes:
 - Package
 - Name Table Entry
 - Import Table Entry
 - Export Table Entry
-- Object: serialized data, referenced in Export Table Entry
+- Object: serialized data referenced in the Export Table Entry
 
-OFFSET key sets a scope to entire package, excluding first 8 bytes, as changing package signature and version
-is not allowed. Offset sets write pointer to specified ABSOLUTE file offset (i.e. from the very beginning - 0 byte).
-You may use dec and hex value representation.
+OFFSET key sets the scope to an entire package (excluding first 8 bytes as changing package signature and version
+is not allowed). The key sets a stream position to an ABSOLUTE file offset (i.e. from the very beginning - byte 0).
+You can use dec and hex value representation.
 OFFSET=0xA1B2
 OFFSET=12345
 
-NAME_ENTRY, IMPORT_ENTRY and EXPORT_ENTRY keys set scope to specified table entry: unique name for NAME_ENTRY
-and full object name for IMPORT_ENTRY and EXPORT_ENTRY:
-NAME_ENTRY=GetAltWeapon
-IMPORT_ENTRY=XComGame.XComGameInfo.PerkContents
-EXPORT_ENTRY=XGStrategyAI.GetAltWeapon
+NAME_ENTRY, IMPORT_ENTRY and EXPORT_ENTRY keys set the scope to a table entry: name entry for NAME_ENTRY
+and object entry for IMPORT_ENTRY and EXPORT_ENTRY:
+NAME_ENTRY=GetAltWeapon // use unique name here
+IMPORT_ENTRY=XComGame.XComGameInfo.PerkContents // use full object name here
+EXPORT_ENTRY=XGStrategyAI.GetAltWeapon // use full object name here
 
-OBJECT key sets the current scope to specified export object:
+OBJECT key sets the scope to an export object:
 OBJECT=XGStrategyAI.GetAltWeapon
-Value of this key may be used with specifiers:
+This key has specifiers:
 OBJECT=XGStrategyAI.GetAltWeapon:KEEP
 OBJECT=XGStrategyAI.GetAltWeapon:MOVE
 OBJECT=XGStrategyAI.GetAltWeapon:AUTO
 OBJECT=XGStrategyAI.GetAltWeapon:INPL
-If specifier is empty, KEEP is assumed. KEEP provides a most safest behavior: write operations will be performed
-inside specified scope only. It means, if data chunk exceeds object's size, write operation will fail.
-MOVE specifier forces object data move before applying any changes.
+If specifier is empty, KEEP is assumed. KEEP provides the most safest behavior: write operations will be performed
+inside the scope only. It means, if a data chunk exceeds object's size, write operation will fail.
+MOVE specifier forces moving object's data before applying any changes.
 AUTO specifier allows program to auto-move/resize object when needed.
 INPL specifier works similar to AUTO, but resizes object in-place instead of moving it.
-Note that modifiers themselves do not make any changes: they work when you start to write actual data.
+Note that specifiers themselves do not make any changes: they work when you start to write actual data.
     
 -----------------------------------------------------------------------------------------------------------------
     Setting a relative offset
 -----------------------------------------------------------------------------------------------------------------
 
-REL_OFFSET key is used to set relative offset inside current scope. Example:
+REL_OFFSET key is used to set a relative offset inside the scope. Example:
 REL_OFFSET=0x30
 REL_OFFSET=48
 
 -----------------------------------------------------------------------------------------------------------------
-    Finding the binary data
+    Finding a binary data
 -----------------------------------------------------------------------------------------------------------------
 
-FIND_HEX key is used to find specified data and set the relative offset to the beginning of that data:
+FIND_HEX key is used to find the data and set a relative offset to the beginning of that data:
 FIND_HEX=0A 0B 12 34
-Value of FIND_HEX is a space-separated hex-represented bytes string. You may use comments and multiline strings
-inside FIND_HEX value.
+The value of FIND_HEX is a space-separated hex-represented string of bytes. You can use comments and multiline
+strings inside FIND_HEX value.
 
-Since v.3.2 FIND_HEX can be used with modifiers: BEG and END. Examples:
+FIND_HEX has two specifiers: BEG and END. Examples:
 FIND_HEX=0A 0B 12 34:BEG
 FIND_HEX=0A 0B 12 34:END
-Using BEG will set current offset to the beginning of search string and using END will set the offset to the end
-of search string. If no modifier is present, BEG is assumed.
+Using BEG will set the offset to the beginning of the search string and using END will set the offset to the
+end of it. If no specifier is present, BEG is assumed.
 
-WARNING! Since v.3.2 FIND_HEX no longer sets temporary scope! It sets current offset only, as the very first
-version did!
-    
 -----------------------------------------------------------------------------------------------------------------
-    Writing the binary data
+    Writing a binary data
 -----------------------------------------------------------------------------------------------------------------
 
-MODDED_HEX key is used to write specified data at current offset inside current scope. Value is the same as for
-FIND_HEX: space-separated hex-represented bytes string, may be multiline, may use comments.
+MODDED_HEX key is used to write the data at relative offset inside current scope. The value is the same as for
+FIND_HEX: space-separated hex-represented string of bytes, can be multiline, can use comments.
 MODDED_HEX=0A 0B 12 34
 If AUTO or MOVE object specifier is used, program will attempt to auto-expand current object to fit MODDED_HEX
-data. Auto-expand works for export object serial data only, table entries won't be expanded.
+data. Auto-expand works for export object's serial data only, table entries won't be expanded.
 
 MODDED_FILE key is used to read modded binary data from separate file.
 MODDED_FILE=path-to-file.ext
 
 MODDED_FILE is considered a total replacement for current scope: i.e. it should contain full object data. It is
 also required to use Full.Object.Name.ext pattern for file name, so program could auto-set scope, based on file
-name. Object data files must use .Type as their extension and table entries must use .NameEntry, .ImportEntry and
-.ExportEntry respectively. Examples:
+name. Object data files should use .Type as their extension and table entries should use .NameEntry,
+.ImportEntry and .ExportEntry respectively. Examples:
 MODDED_FILE=XGStrategyAI.GetAltWeapon.Function
 MODDED_FILE=GetAltWeapon.NameEntry
 MODDED_FILE=XComGame.XComGameInfo.PerkContents.ImportEntry
 MODDED_FILE=XGStrategyAI.GetAltWeapon.ExportEntry
 You can use the same specifiers as for OBJECT key with MODDED_FILE key, although they will work for objects only
-and will be ignored for table entries. After successful patching, current scope will be set to specified object.
-Since modded file contains an object replacement code, export object data will be resized (expanded or shrunk)
-accordingly if AUTO or MOVE modifier is set.
+and will be ignored for table entries. After successful patching current scope will be set to the object. Since
+modded file contains an object replacement code, export object data will be resized (expanded or shrunk)
+accordingly if AUTO or MOVE specifier is set.
 
 BYTE, FLOAT, INTEGER and UNSIGNED keys are used to set corresponding values. BYTE value is unsigned dec or hex
 represented 1-byte value. FLOAT and INTEGER are signed dec-represented 4-byte values. UNSIGNED is unsigned dec
 or hex represented 4-byte value.
 
-NAMEIDX key is used to write UNameIndex 8-byte value, determined by specified name. Example:
+NAMEIDX key is used to write UNameIndex 8-byte value determined by the name. Example:
 NAMEIDX=GetAltWeapon
 
-OBJIDX key is used to write UObjectReference 4-byte signed value, determined by object's full name. Example:
+OBJIDX key is used to write UObjectReference 4-byte signed value determined by the full name. Example:
 OBJIDX=XGStrategyAI.GetAltWeapon
    
 -----------------------------------------------------------------------------------------------------------------
     Modifying object table entry
 -----------------------------------------------------------------------------------------------------------------
 
-RENAME key is used to rename an entry in NameTable:
+RENAME key is used to rename an entry in the Name Table:
 RENAME=GetAltWeapon:#GetPodProgs
-Changing entry size is not allowed, so new name length must be equal to old name length. After successful
-renaming, current scope will be set to new Name Table name.
+Changing entry size is not allowed, so new name length should be equal to old name length. After successful
+renaming current scope will be set to new Name Table name.
 
-If entry is already renamed, program will just set current scope to it and continue patching.
+If entry is already renamed program will just set current scope to it and continue patching.
 
 -----------------------------------------------------------------------------------------------------------------
     Expanding a function
 -----------------------------------------------------------------------------------------------------------------
 
-EXPAND_FUNCTION is a key, used to expand functions:
+EXPAND_FUNCTION key is used to expand functions:
 EXPAND_FUNCTION=XGStrategyAI.GetPossibleAliens:5828
 It will expand function code by adding 0B (nop) tokens and modifying serial and memory size accordingly and set
-current scope to specified object after successful patching. If function already has specified size, it will do
+current scope to the object after successful patching. If function already is of requested size, it will do
 nothing.
 EXPAND_FUNCTION will also expand other objects by simply appending zeroes to the end of object data (for backward-
 compatibility reasons).
 
 EXPAND_UNDO key is used to undo move/expand operation:
 EXPAND_UNDO=XGStrategyAI.GetAltWeapon
-As move/expand operation keeps original data in place, EXPAND_UNDO simply restores ExportTable references to
-the old data. No other changes are made and no "garbage" (expanded object binary) is collected. Used mostly
-for uninstall purposes.
+As move/expand operation keeps original data in place, EXPAND_UNDO simply restores ExportTable references.
+No other changes are made and no "garbage" (expanded object binary) is collected. Used mostly for uninstall
+purposes.
     
 -----------------------------------------------------------------------------------------------------------------
     Section-style patching
 -----------------------------------------------------------------------------------------------------------------
 
-Some time ago I decided that sections are bulky and may be easily replaced with keys, while keeping all
-functionality. But for the sake of backward-compatibility (and because IDIC matters!) program still supports
-sections.
+All the keys can also be written as sections (for compatibility reasons and because IDIC matters).
 
-[MODDED_HEX] section is equal to MODDED_HEX key. Example:
+[MODDED_HEX] section is an equivalent of MODDED_HEX key. Example:
 [MODDED_HEX]
 AB CD 12 34
-You may use [/MODDED_HEX] to visually mark section end, but it is purely optional.
+You can use [/MODDED_HEX] to visually mark section end, but it is purely optional.
 
-[FIND_HEX] (with optional [/FIND_HEX]) is equal to FIND_HEX key.
+[FIND_HEX] (with optional [/FIND_HEX]) is an equivalent of FIND_HEX key.
     
 -----------------------------------------------------------------------------------------------------------------
     Find-and-replace (FNR) style patching (UPKModder compatibility)
 -----------------------------------------------------------------------------------------------------------------
 
-Since v.3.2 BEFORE_HEX and AFTER_HEX are considered a unique commands and behave similar to those of UPKModder.
+BEFORE_HEX and AFTER_HEX are unique commands that behave similar to those of UPKModder.
 
-[BEFORE_HEX] (with optional [/BEFORE_HEX]) will set current scope to search string.
+[BEFORE_HEX] (with optional [/BEFORE_HEX]) sets current scope to search string.
 
 [AFTER_HEX] (with optional [/AFTER_HEX]) string is considered a replacement for BEFORE_HEX string and can not be
 used without calling BEFORE_HEX first.
 
-If FNR operation is performed within export object scope, it will respect OBJECT key modifiers: for KEEP it will
+If FNR operation is performed within export object scope it will respect OBJECT key specifiers: for KEEP it will
 require AFTER_HEX data length be equal to BEFORE_HEX data length and for AUTO and MOVE it will auto-expand
 (or shrink) BEFORE_HEX scope to fit AFTER_HEX data. Program will auto-adjust script serial size for objects with
-scripts (functions and states), but it won't do anything about script memory size, as it doesn't know anything
+scripts (functions and states), but it won't do anything about script memory size as it doesn't know anything
 about it (see "Using pseudo-code" section below for pseudo-code version which does calculate and rewrite both
 serial and memory sizes).
 
@@ -233,7 +226,7 @@ See "Using pseudo-code" section for BEFORE_CODE/AFTER_CODE combination, which ca
 memory sizes.
 
 REPLACE_HEX/REPLACE_CODE keys are used to batch-replace specified data. They perform subsequent BEFORE/AFTER
-patching inside current scope, until all the blocks of before data are found and replaced.
+patching inside current scope until all the blocks of before data are found and replaced.
 
 Example:
 REPLACE_CODE=<.LocalVarA>:<.LocalVarB>
@@ -242,7 +235,7 @@ REPLACE_CODE=<.LocalVarA>:<.LocalVarB>
     Writing bulk data
 -----------------------------------------------------------------------------------------------------------------
 
-BULK_DATA/BULK_FILE keys allow to write BulkDataMirror objects, which use absolute file offsets to mark raw data
+BULK_DATA/BULK_FILE keys allow to write BulkDataMirror objects which use absolute file offset to mark raw data
 file position. BulkDataMirror objects are used to store textures and sounds inside cooked packages.
 
 Examples:
@@ -256,8 +249,8 @@ BULK_FILE=path/to/binaryfile.ext
 As PatchUPK can auto-convert object/name references to hex code, you can write scripts (and plain references) in
 pseudo-code.
 
-Pseudo-code is enclosed in '<' and '>' brackets. Since v.4.0 you can use any type of white-spaces and comments
-inside brackets. Example:
+Pseudo-code is enclosed in '<' and '>' brackets. You can use any type of white-spaces and comments inside brackets.
+Example:
 <%b
 // user-changeable section: set sniper class probability
 25
@@ -267,15 +260,13 @@ inside brackets. Example:
 -------
 Syntax:
 -------
-1. Numeric constants:
-    <%c Value>, where c is a single-character format specifier:
+1. Numeric constants: <%c Value>, where c is a single-character format specifier:
         f - float (4 bytes)
         i - signed integer (4 bytes)
         u - unsigned integer (4 bytes)
         s - short unsigned integer (2 bytes)
         b - byte (1 byte)
         t - text (variable-size string)
-    and Value is a numeric.
     Examples:
         <%f  1.0>
         <%i -1>
@@ -285,28 +276,30 @@ Syntax:
         <%t  "text">
         <%t  "text with spaces "and inner quotes"">
 2. Object references:
-    <Class.ClassName> - class reference, must begin with "Class."!
+    <Class.ClassName> - class reference, should begin with "Class."!
     <ClassName.ObjName> - object reference (full object name).
-    <.LocalObjName> - local object reference, must begin with ".". Full name is constructed by prepending local
-    name with full name of current export object. Can not be used outside of export object scope.
-    <@MemberObjName> - member object reference, full object name is constructed by prepending member name with
-    class name, determined from current export object name. Can not be used outside of export object scope.
+    <.LocalObjName> - local object reference, should begin with ".". Full name is reconstructed by prepending
+	local name with full name of current export object. Can not be used outside of export object scope.
+    <@MemberObjName> - member object reference, full object name is reconstructed by prepending member name
+	with class name determined from current export object name. Can not be used outside of export object scope.
     <!AliasName> - alias reference (see ALIAS key description below).
     <NullRef> - null object reference (0x00000000) with 4 serial and 8 memory size.
 3. Name reference:
     <Name> - plain simple name.
+4. [@label_name] and [#label_name], [@] and () - labels and references for auto-calculating memory offsets
+   (see below).
 
 ------------------
 Keys and sections:
 ------------------
 MODDED_CODE (key and section) - used to write a modded code at current scope, equivalent of MODDED_HEX.
-FIND_CODE (key and section) - used to find specified code, equivalent of FIND_HEX.
+FIND_CODE (key and section) - used to find the code, equivalent of FIND_HEX.
 INSERT_CODE (key and section) - used to insert a code at current position. Requires AUTO behavior, as it will
 resize current object to insert new data. Works with export object data only. Does not change memory/file size
 of a script! Useful for inserting additional default properties into default property list. Warning! Using
-this function for mod distribution is dangerous, as if applied twice it will add specified code twice!
+this function for mod distribution is not recommended, as if applied twice it will add the code twice!
 BEFORE_CODE and AFTER_CODE (sections) - behave like BEFORE_HEX and AFTER_HEX, but calculate and write correct
-serial and memory sizes in case of expanding/shrinking the object with script.
+serial and memory sizes in case of expanding/shrinking the object.
 
 Pseudo-code example:
 [MODDED_CODE]
@@ -348,9 +341,9 @@ ALIAS (key) - used to define alias name for a portion of code. Syntax:
     // if(Game().GetDifficulty() >= 2)
     07 00 00 99 <!GameDiff> 2C <%b2> 16
 
-Aliases are searched scope-wise: if alias is defined inside object scope, it considered local to that scope.
-While searching for alias replacement code, program first looks in the local scope and then in the global scope.
-This means you may have different aliases with the same names inside different objects.
+Aliases are searched scope-wise: if alias is defined inside object scope it is considered local to that
+scope. While searching for alias replacement code program first looks in the local scope and then in
+the global scope. This means you can have different aliases with the same names inside different scopes.
 
 Example of locally defined alias:
 OBJECT=XGStrategyAI.GetNumOutsiders:AUTO
@@ -371,15 +364,18 @@ Replacement code:
 -----------------
 
 REPLACEMENT_CODE (key and section) is used to completely replace export object script with the new one. Works
-only with objects, which have scripts (like functions and states). Will expand/shrink object if necessary and if
-current behavior is set to "AUTO" or "MOVE". Will auto-calculate and re-write memory and serial script size.
+only with objects which have scripts (like functions and states). Will expand/shrink object if necessary and
+if current behavior is set to "AUTO" or "MOVE". Will auto-calculate and re-write memory and serial script size.
 
-You can use CODE keys/sections with pure hex data, but in this case REPLACEMENT_CODE will set wrong memory size
-(equal to serial script size). You may still set memory size manually, but you must do it after REPLACEMENT_CODE
-call. Same way, memory size won't be calculated properly if you mix pure hex data with the pseudo-code.
+You can use CODE keys/sections with pure/partial hex data, but in this case the memory size will be wrong and
+you will need to set it manually. If you choose to do this, you should do it after REPLACEMENT_CODE call.
 
-You can label a token inside a code with [#label] and reference that label with [@label]. Label names must be
-unique (see example below). Don't use labels if you mix pure hex with pseudo-code, as references will be wrong!
+----------------------
+Labels and references:
+----------------------
+
+You can label a token inside a code with [#label] and reference it with [@label]. Label names must be unique
+(see example below). Don't use labels if you mix pure hex with pseudo-code, as references will be wrong!
 
 Example:
 OBJECT=XGStrategyAI.GetNumOutsiders:AUTO
@@ -399,6 +395,13 @@ OBJECT=XGStrategyAI.GetNumOutsiders:AUTO
 // EOS
 53
 
+You can use empty reference [@] and a pair of parentheses to auto-calculate memory size/skip size. Example:
+// if(Game().GetDifficulty() >= 2)
+07 [@label1] 99 19 1B <Game> 16 [@] <XGStrategy.GetDifficulty.ReturnValue> 00 ( 1B <GetDifficulty> 16 ) 2C <%b2> 16
+
+[@] marks the place of memory size to calculate and parentheses mark the beginning and the end of the code
+which size needs to be auto-calculated.
+
 -----------------------------------------------------------------------------------------------------------------
     Adding new names and objects
 -----------------------------------------------------------------------------------------------------------------
@@ -406,10 +409,11 @@ OBJECT=XGStrategyAI.GetNumOutsiders:AUTO
 Warning! This feature is highly experimental and can completely mess up your packages! Use with caution!
 
 There are three main keys/sections for adding new objects:
-1. ADD_NAME_ENTRY - adds a name entry into name table.
-2. ADD_IMPORT_ENTRY - adds import entry into import table.
-3. ADD_EXPORT_ENTRY - adds export entry into export table and links new object to specified owner. Always writes
-   at least 16 bytes long serialized data: PrevObjRef + Empty DefaultProperties List + NextObjRef
+1. ADD_NAME_ENTRY - adds a name entry into the name table.
+2. ADD_IMPORT_ENTRY - adds an import entry into the import table.
+3. ADD_EXPORT_ENTRY - adds an export entry into the export table and links the new object to specified owner.
+                      Always writes at least 16 bytes long serialized data:
+					  PrevObjRef + Empty DefaultProperties List + NextObjRef
    
 Example: adding a new WGhost81 local variable to XGStrategyAI.GetNumOutsiders function
 
@@ -447,15 +451,15 @@ REL_OFFSET=16   // skip PrevObjRef + Empty DefaultProperties List + NextObjRef
 <None>          // CategoryIndex
 <NullRef>	    // ArrayEnumRef
 
-Note that all entries are actually raw data, written in PatchUPK pseudo-code. Patcher will get it as pure HEX
+Note that all entries are actually raw data written in PatchUPK pseudo-code. Patcher will get it as pure HEX
 code, deserialize it and link to owner if necessary. Patcher will not construct proper serial data for you,
-you must do it yourself after adding an object!
+you should do it yourself after adding an object!
 
 -----------------------------------------------------------------------------------------------------------------
     Legacy support: deprecated/renamed keys
 -----------------------------------------------------------------------------------------------------------------
 
-You may still use those, but it is recommended to move to new commands.
+You can still use those, but it is recommended to move on to new commands.
 
 FUNCTION key is an alias to OBJECT key. Renamed for obvious reasons: not all objects are functions.
 
@@ -467,7 +471,7 @@ NAMELIST_NAME key is an alias to much shorter RENAME key.
     Uninstall scripts
 -----------------------------------------------------------------------------------------------------------------
 
-When installing mod, PatchUPK automatically generates uninstall script and writes it to
+When installing mod PatchUPK automatically generates uninstall script and writes it to
 your_mod_file_name.uninstall.txt. "Installing" .uninstall.txt "mod" will not generate another uninstall file.
 In case your_mod_file_name.uninstall.txt already exists, program will generate your_mod_file_name.uninstall1.txt
 and so on.
diff --git a/doc/UPKUtils_Readme.txt b/doc/UPKUtils_Readme.txt
index 5d42b13..d81626a 100644
--- a/doc/UPKUtils_Readme.txt
+++ b/doc/UPKUtils_Readme.txt
@@ -2,17 +2,27 @@
     UPK Utils documentation file
 -----------------------------------------------------------------------------------------------------------------
 
-UPK Utils are a set of Windows console applications for analysing and patching uncompressed XCOM packages (.upk).
+UPK Utils are a set of console applications for analysing and patching XCOM packages (.upk).
 
-Version 6.1, 10/03/2014
+-----------------------------------------------------------------------------------------------------------------
+    DecompressLZO
+-----------------------------------------------------------------------------------------------------------------
+
+An utility to decompress upk files using LZO compression algorithm.
 
-Wasteland Ghost aka wghost81 (wghost81@gmail.com).
+Usage: DecompressLZO CompressedResourceFile.upk [DecompressedCompressedResourceFile.upk]
+
+If DecompressedCompressedResourceFile.upk is not specified, decompressed package is saved to
+CompressedResourceFile.upk.uncompr file.
+
+Works with compressed and fully compressed packages.
 
 -----------------------------------------------------------------------------------------------------------------
     ExtractNameLists
 -----------------------------------------------------------------------------------------------------------------
 
-This program is used to read package header and output the information to the console.
+The program reads package header (package information, name, import and export tables) and outputs the data
+to the console.
 
 Usage:
 ExtractNameLists UnpackedResourceFile.upk [/v]
@@ -21,22 +31,22 @@ Examples:
 ExtractNameLists.exe XComStrategyGame.upk
 ExtractNameLists.exe XComStrategyGame.upk /v
     
-To redirect output from console to text file type:
+To redirect output from the console to a text file type:
 ExtractNameLists UnpackedResourceFile.upk > file_name.txt
 Examples:
 ExtractNameLists.exe XComStrategyGame.upk > XComStrategyGame.txt
 ExtractNameLists.exe XComStrategyGame.upk /v > XComStrategyGame.txt
 
-This will redirect output to file_name.txt. Error messages will still be output into console.
+This will redirect output to file_name.txt. Error messages will still be printed into the console.
 
-If package is compressed, program will try to read and output compression info.
+If package is compressed, program will try to read and print compression info.
 
 -----------------------------------------------------------------------------------------------------------------
     FindObjectEntry
 -----------------------------------------------------------------------------------------------------------------
 
-This program is used to find specified object in specified package and output the information to the console.
-Program will also try to deserialize object's data and output all the info available.
+The program finds a specified object in a specified package and outputs the information to the console.
+Program will also try to deserialize object's data and print all the data available.
 
 Usage:
 FindObjectEntry UnpackedResourceFile.upk ObjectName [/d]
@@ -46,18 +56,18 @@ FindObjectEntry UnpackedResourceFile.upk ObjectName [/d]
 Example:
 FindObjectEntry.exe XComStrategyGame.upk XGFacility_PsiLabs.TPsiTrainee
 
-You can redirect output to file:
+You can redirect output to a file:
 FindObjectEntry.exe XComStrategyGame.upk XGFacility_PsiLabs.TPsiTrainee > XGFacility_PsiLabs.TPsiTrainee.txt
 
-FindObjectEntry will now try to deserialize unknown objects. It shouldn't crash in case of wrong guess about
-object's data, but may output wrong or incomplete data sometimes. Anyway, it will output a warning about object's
+FindObjectEntry will try to deserialize unknown objects. It shouldn't crash in case of wrong guess about
+object's data, but may give wrong or incomplete data sometimes. It will give a warning about object's
 type being unknown.
 
 -----------------------------------------------------------------------------------------------------------------
     FindObjectByOffset
 -----------------------------------------------------------------------------------------------------------------
 
-This program is used to find an export object full name by specified offset.
+The program finds an export object full name by specified offset.
 
 Usage:
 FindObjectByOffset UnpackedResourceFile.upk offset
@@ -67,7 +77,7 @@ FindObjectByOffset UnpackedResourceFile.upk offset
     DeserializeAll
 -----------------------------------------------------------------------------------------------------------------
 
-This program is used to batch-deserialization of package Export Objects.
+The program performs batch-deserialization of all Export Objects inside a specified package.
 
 Usage:
 DeserializeAll UnpackedResourceFile.upk [NameMask]
@@ -86,10 +96,22 @@ map objects. But it is helpful in analysing TheWorld.PersistentLevel objects, as
 contain Default Properties only.
     
 -----------------------------------------------------------------------------------------------------------------
-    MoveExpandFunction
+    PatchUPK
 -----------------------------------------------------------------------------------------------------------------
 
-This program is used to move/expand specified function or to undo previous move/expand operation.
+An utility to apply UPK patches. For more information see PatchUPK_Readme.txt.
+
+Usage:
+PatchUPK modfile.txt [PATH_TO_UPK]
+    modfile.txt — mod script (see PatchUPK_Readme.txt and PatchUPK_Mod_Example.txt)
+    PATH_TO_UPK — path to folder where packages are located (optional parameter)
+
+
+-----------------------------------------------------------------------------------------------------------------
+    MoveExpandFunction (Deprecated)
+-----------------------------------------------------------------------------------------------------------------
+
+The program performs move/expand operations for a specified function. Can undo previous move/expand operation.
 
 Usage:
 MoveExpandFunction UnpackedResourceFile.upk FunctionName [NewFunctionSize or /u]
@@ -101,39 +123,15 @@ Examples:
 MoveExpandFunction.exe XComStrategyGame.upk XGStrategyAI.GetAltWeapon 300
 MoveExpandFunction.exe XComStrategyGame.upk XGStrategyAI.GetAltWeapon /u
 
------------------------------------------------------------------------------------------------------------------
-    PatchUPK
------------------------------------------------------------------------------------------------------------------
-
-This program is used to apply package patches. For more information see PatchUPK_Readme.txt.
-
-Usage:
-PatchUPK modfile.txt [PATH_TO_UPK]
-    modfile.txt — mod script (see PatchUPK_Readme.txt and PatchUPK_Mod_Example.txt)
-    PATH_TO_UPK — path to folder, where packages are stored (optional parameter)
-
-
 -----------------------------------------------------------------------------------------------------------------
     CompareUPK
 -----------------------------------------------------------------------------------------------------------------
 
-A program to compare packages. Useful for analysing patches. Slow. Really slow. :)
+An utility to compare packages. Useful for analysing patches. Slow. Really slow. :)
 
 Usage:
 CompareUPK OldPackage.upk NewPackage.upk
 
------------------------------------------------------------------------------------------------------------------
-    DecompressLZO
------------------------------------------------------------------------------------------------------------------
-
-An utility to decompress upk files using LZO compression algorithm.
-
-Usage: DecompressLZO CompressedResourceFile.upk
-
-Decompressed package is saved to CompressedResourceFile.upk.uncompr file.
-
-Works with compressed and fully compressed packages.
-
 -----------------------------------------------------------------------------------------------------------------
     XComLZO
 -----------------------------------------------------------------------------------------------------------------